how to use multiple database connection?

first take a class which name it as DBmanger:



using System;
using System.Data;
using System.Data.Odbc;
using System.Data.SqlClient;
using System.Data.OleDb;
using System.Data.OracleClient;

namespace DataAccessLayer
{
    public sealed class DBManager : IDBManager, IDisposable
    {
        private IDbConnection idbConnection;
        private IDataReader idataReader;
        private IDbCommand idbCommand;
        private DataProvider providerType;
        private IDbTransaction idbTransaction = null;
        private IDbDataParameter[] idbParameters = null;
        private string strConnection;

        public DBManager()
        {

        }

        public DBManager(DataProvider providerType)
        {
            this.providerType = providerType;
       }

        public DBManager(DataProvider providerType, string connectionString)
        {
            this.providerType = providerType;
            this.strConnection = connectionString;
        }

        public IDbConnection Connection
        {
            get
            {
                return idbConnection;
            }
        }

        public IDataReader DataReader
        {
            get
            {
                return idataReader;
            }
            set
            {
                idataReader = value;
            }
        }

        public DataProvider ProviderType
        {
            get
            {
                return providerType;
            }
            set
            {
                providerType = value;
            }
        }

        public string ConnectionString
        {
            get
            {
                return strConnection;
            }
            set
            {
                strConnection = value;
            }
        }

        public IDbCommand Command
        {
            get
            {
                return idbCommand;
            }
        }

        public IDbTransaction Transaction
        {
            get
            {
                return idbTransaction;
            }
        }

        public IDbDataParameter[] Parameters
        {
            get
            {
                return idbParameters;
            }
        }

        public void Open()
        {
            idbConnection =
            DBManagerFactory.GetConnection(this.providerType);
            idbConnection.ConnectionString = this.ConnectionString;
            if (idbConnection.State != ConnectionState.Open)
                idbConnection.Open();
            this.idbCommand = DBManagerFactory.GetCommand(this.ProviderType);
        }

        public void Close()
        {
            if (idbConnection.State != ConnectionState.Closed)
                idbConnection.Close();
        }

        public void Dispose()
        {
            GC.SuppressFinalize(this);
            this.Close();
            this.idbCommand = null;
            this.idbTransaction = null;
            this.idbConnection = null;
        }

        public void CreateParameters(int paramsCount)
        {
            idbParameters = new IDbDataParameter[paramsCount];
            idbParameters = DBManagerFactory.GetParameters(this.ProviderType, paramsCount);
        }

        public void AddParameters(int index, string paramName, object objValue, Object paramDbType)
        {
            if (index < idbParameters.Length)
            {
                idbParameters[index].ParameterName = paramName;
                DBManagerFactory.SetParameterType(this.providerType, paramDbType, idbParameters[index]);
                //idbParameters[index].DbType =paramDbType;
                //idbParameters[index].Direction = paramDirection;
                if (objValue != null)
                    idbParameters[index].Value = objValue;
            }
        }

        public void AddParameters(int index, string paramName, object objValue, Object paramDbType, ParameterDirection paramDirection)
        {
            if (index < idbParameters.Length)
            {
                idbParameters[index].ParameterName = paramName;
                DBManagerFactory.SetParameterType(this.providerType, paramDbType, idbParameters[index]);
                idbParameters[index].Direction = paramDirection;
                if (objValue != null)
                    idbParameters[index].Value = objValue;
                //idbParameters[index].Size = size;
            }
        }

        public void BeginTransaction()
        {
            if (this.idbTransaction == null)
                idbTransaction = DBManagerFactory.GetTransaction(this.ProviderType);
            this.idbCommand.Transaction = idbTransaction;
        }

        public void CommitTransaction()
        {
            if (this.idbTransaction != null)
                this.idbTransaction.Commit();
            idbTransaction = null;
        }

        public void RollBackTransaction()
        {
            if (this.idbTransaction != null)
                this.idbTransaction.Rollback();
            idbTransaction = null;
        }
        public IDataReader ExecuteReader(CommandType commandType, string commandText)
        {
            this.idbCommand = DBManagerFactory.GetCommand(this.ProviderType);
            idbCommand.Connection = this.Connection;
            PrepareCommand(idbCommand, this.Connection, this.Transaction, commandType, commandText, this.Parameters);
            this.DataReader = idbCommand.ExecuteReader();
            idbCommand.Parameters.Clear();
            return this.DataReader;
        }

        public void CloseReader()
        {
            if (this.DataReader != null)
                this.DataReader.Close();
        }

        private void AttachParameters(IDbCommand command, IDbDataParameter[] commandParameters)
        {
            foreach (IDbDataParameter idbParameter in commandParameters)
            {
                if ((idbParameter.Direction == ParameterDirection.InputOutput) && (idbParameter.Value == null))
                {
                    idbParameter.Value = DBNull.Value;
                }
                command.Parameters.Add(idbParameter);
            }
        }

        private void PrepareCommand(IDbCommand command, IDbConnection connection,
                                    IDbTransaction transaction, CommandType commandType,
                                     string commandText, IDbDataParameter[] commandParameters)
        {
            command.Connection = connection;
            command.CommandText = commandText;
            command.CommandType = commandType;

            if (transaction != null)
            {
                command.Transaction = transaction;
            }

            if (commandParameters != null)
            {
                AttachParameters(command, commandParameters);
            }
        }

        public int ExecuteNonQuery(CommandType commandType, string commandText)
        {
            this.idbCommand = DBManagerFactory.GetCommand(this.ProviderType);
            PrepareCommand(idbCommand, this.Connection, this.Transaction, commandType, commandText, this.Parameters);
            int returnValue = idbCommand.ExecuteNonQuery();
            idbCommand.Parameters.Clear();
            return returnValue;
        }

        public object ExecuteScalar(CommandType commandType, string commandText)
        {
            this.idbCommand = DBManagerFactory.GetCommand(this.ProviderType);
            PrepareCommand(idbCommand, this.Connection, this.Transaction, commandType, commandText, this.Parameters);
            object returnValue = idbCommand.ExecuteScalar();
            idbCommand.Parameters.Clear();
            return returnValue;
        }

        public DataSet ExecuteDataSet(CommandType commandType, string commandText)
        {
            this.idbCommand = DBManagerFactory.GetCommand(this.ProviderType);
            PrepareCommand(idbCommand, this.Connection, this.Transaction, commandType, commandText, this.Parameters);
            IDbDataAdapter dataAdapter = DBManagerFactory.GetDataAdapter(this.ProviderType);
            dataAdapter.SelectCommand = idbCommand;
            DataSet dataSet = new DataSet();
            dataSet.EnforceConstraints = false;
            dataAdapter.Fill(dataSet);
            idbCommand.Parameters.Clear();

            return dataSet;

        }

        #region IDisposable Members

        void IDisposable.Dispose()
        {
            throw new NotImplementedException();
        }

        #endregion
    }
}







take another class and name it as DBManagerFactory:
using System.Data;
using System.Data.Odbc;
using System.Data.OleDb;
using System.Data.OracleClient;
using System.Data.SqlClient;
using MySql.Data.MySqlClient;
using System;

namespace DataAccessLayer
{
    public sealed class DBManagerFactory
    {
        private DBManagerFactory() { }
        public static IDbConnection GetConnection(DataProvider providerType)
        {
            IDbConnection iDbConnection = null;
            switch (providerType)
            {
                case DataProvider.SqlServer:
                    iDbConnection = new SqlConnection();
                    break;
                case DataProvider.OleDb:
                    iDbConnection = new OleDbConnection();
                    break;
                case DataProvider.Odbc:
                    iDbConnection = new OdbcConnection();
                    break;
                case DataProvider.Oracle:
                    iDbConnection = new OracleConnection();
                    break;
                case DataProvider.MySql:
                    iDbConnection = new MySqlConnection();
                    break;
                default:
                    return null;
            }
            return iDbConnection;
        }

        public static IDbCommand GetCommand(DataProvider providerType)
        {
            switch (providerType)
            {
                case DataProvider.SqlServer:
                    return new SqlCommand();
                case DataProvider.OleDb:
                    return new OleDbCommand();
                case DataProvider.Odbc:
                    return new OdbcCommand();
                case DataProvider.Oracle:
                    return new OracleCommand();
                case DataProvider.MySql:
                    return new MySqlCommand();
                default:
                    return null;
            }
        }


        public static bool SetParameterType(DataProvider providerType, Object ObjParameterDBType, Object idbParameter)
        {
            switch (providerType)
            {
                case DataProvider.SqlServer:
                    SqlParameter pSqlParameter = (SqlParameter)idbParameter;
                    pSqlParameter.SqlDbType = (SqlDbType)ObjParameterDBType;
                    return true;
                case DataProvider.OleDb:
                    OleDbParameter pOleDbParameter = (OleDbParameter)idbParameter;
                    pOleDbParameter.OleDbType = (OleDbType)ObjParameterDBType;
                    return true;
                case DataProvider.Odbc:
                    OdbcParameter pOdbcParameter = (OdbcParameter)idbParameter;
                    pOdbcParameter.OdbcType = (OdbcType)ObjParameterDBType;
                    return true;
                case DataProvider.Oracle:
                    OracleParameter pOracleParameter = (OracleParameter)idbParameter;
                    pOracleParameter.OracleType = (OracleType)ObjParameterDBType;
                    return true;
                //case DataProvider.MySql:
                //    MySqlParameter pMySqlParameter = (MySqlParameter)idbParameter;
                //    pMySqlParameter.MySqlType = (MySqlType)ObjParameterDBType;
                //    return true;
               
                default:
                    return true;
            }
        }


        public static IDbDataAdapter GetDataAdapter(DataProvider providerType)
        {
            switch (providerType)
            {
                case DataProvider.SqlServer:
                    return new SqlDataAdapter();
                case DataProvider.OleDb:
                    return new OleDbDataAdapter();
                case DataProvider.Odbc:
                    return new OdbcDataAdapter();
                case DataProvider.Oracle:
                    return new OracleDataAdapter();
                case DataProvider.MySql:
                    return new MySqlDataAdapter();
                default:
                    return null;
            }
        }


        public static IDbTransaction GetTransaction(DataProvider providerType)
        {
            IDbConnection iDbConnection = GetConnection(providerType);
            IDbTransaction iDbTransaction = iDbConnection.BeginTransaction();
            return iDbTransaction;
        }

        public static IDataParameter GetParameter(DataProvider providerType)
        {
            IDataParameter iDataParameter = null;
            switch (providerType)
            {
                case DataProvider.SqlServer:
                    iDataParameter = new SqlParameter();
                    break;
                case DataProvider.OleDb:
                    iDataParameter = new OleDbParameter();
                    break;
                case DataProvider.Odbc:
                    iDataParameter = new OdbcParameter();
                    break;
                case DataProvider.Oracle:
                    iDataParameter = new OracleParameter();
                    break;
                case DataProvider.MySql:
                    iDataParameter = new MySqlParameter();
                    break;

            }
            return iDataParameter;
        }

        public static IDbDataParameter[] GetParameters(DataProvider providerType, int paramsCount)
        {
            IDbDataParameter[] idbParams = new IDbDataParameter[paramsCount];

            switch (providerType)
            {
                case DataProvider.SqlServer:
                    for (int i = 0; i < paramsCount; ++i)
                    {
                        idbParams[i] = new SqlParameter();
                    }
                    break;
                case DataProvider.OleDb:
                    for (int i = 0; i < paramsCount; ++i)
                    {
                        idbParams[i] = new OleDbParameter();
                    }
                    break;
                case DataProvider.Odbc:
                    for (int i = 0; i < paramsCount; ++i)
                    {
                        idbParams[i] = new OdbcParameter();
                    }
                    break;
                case DataProvider.Oracle:
                    for (int i = 0; i < paramsCount; ++i)
                    {
                        idbParams[i] = new OracleParameter();
                    }
                    break;
                case DataProvider.MySql:
                    for (int i = 0; i < paramsCount; ++i)
                    {
                        idbParams[i] = new MySqlParameter();
                    }
                    break;
               
   
                default:
                    idbParams = null;
                    break;
            }
            return idbParams;
        }
    }
}


take another class and name it as IDBManager:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.Odbc;
using System.Data.SqlClient;
using System.Data.OleDb;
using System.Data.OracleClient;
using MySql.Data.MySqlClient;

namespace DataAccessLayer
{
    public interface IDBManager
    {
        DataProvider ProviderType
        {
            get;
            set;
        }

        string ConnectionString
        {
            get;
            set;
        }

        IDbConnection Connection
        {
            get;
        }
        IDbTransaction Transaction
        {
            get;
        }

        IDataReader DataReader
        {
            get;
        }
        IDbCommand Command
        {
            get;
        }

        IDbDataParameter[] Parameters
        {
            get;
        }

        void Open();
        void BeginTransaction();
        void CommitTransaction();
        void CreateParameters(int paramsCount);
        void AddParameters(int index, string paramName, object objValue, Object paramDbType);
        void AddParameters(int index, string paramName, object objValue, Object paramDbType, ParameterDirection paramDirection);
        IDataReader ExecuteReader(CommandType commandType, string commandText);
        DataSet ExecuteDataSet(CommandType commandType, string commandText);
        object ExecuteScalar(CommandType commandType, string commandText);
        int ExecuteNonQuery(CommandType commandType, string commandText);
        void CloseReader();
        void Close();
        void Dispose();
    }
}




take another class and name it as DataProvider:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

public enum DataProvider
{
     Oracle,
     SqlServer,
     OleDb,
     Odbc,
     MySql
    }


For example take one windows form:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;
using DataAccessLayer;
using MySql.Data.MySqlClient;
using System.Text.RegularExpressions;


namespace prjtims
{
    public partial class frmtotremits : Form
    {
        private StreamWriter filewriter;

        public frmtotremits()
        {
            InitializeComponent();
            // btnok.Enabled = false;
        }

        private void btnok_Click(object sender, EventArgs e)
        {

            string str_output;
            IDBManager dbManager = new DBManager(DataProvider.MySql);
            dbManager.ConnectionString = "Server=localhost;Database=aeonrtc;Uid=root;Pwd=root";
            try
            {
                DataSet etm_ticket_data;
                dbManager.Open();
                etm_ticket_data = dbManager.ExecuteDataSet(CommandType.Text, "select distinct count(*),etm_ticket_data.etd_waybill_no, sum(etm_ticket_data.etd_adultfare),sum(etm_ticket_data.etd_childfare),etm_ticket_data.etd_service_code,etm_ticket_data.etd_ticket_type1,etm_ticket_data.etd_ticket_type2,etm_ticket_data.etd_vehicleno,etm_ticket_data.etd_trip_kms, etm_ticket_data.etd_trip_no,etm_ticket_data.etd_tripcollamount,etm_ticket_data.etd_conductorno,etm_ticket_data.etd_conductorname,etm_issue_details.eid_ebtm_no,  etm_issue_details.eid_issue_date, etm_issue_details.eid_driver_name,etm_issue_details.eid_driver_pfno,etm_issue_details.eid_depot_code, etm_issue_details.eid_driver2_pfno from etm_ticket_data left join etm_issue_details on etm_ticket_data.etd_waybill_no=etm_issue_details.eid_waybill_no where etm_issue_details.eid_issue_date between '01-08-2013 00:42:09' and '01-08-2013 13:38:32' and etm_ticket_data.etd_service_code group by etm_ticket_data.etd_ticket_type1,etm_ticket_data.etd_service_code order by etm_ticket_data.etd_service_code;");

             

dbManager.Close();



 catch (Exception ex)
            {
                //Usual Code
            }
            finally
            {
                dbManager.Dispose();

                MessageBox.Show("Successfully saved");
            }
        }

we can use any conn

If i am not wrong, I can not see where argument str is used in Connection function.
And in web.config, you have multiple connection string, but in Connection method, ["Pcon"] is hard coded, you need to use str in place of hard codded value.