几年前写的一个支持多数据库切换的设计

前言

最新心血来潮，决定把以前做的一些东西做一些整理，于是就有这一篇文章，这次决定写的是大学时期做的一个小项目，里面关于数据库访问的SqlHelper类，项目采用CS结构，支持多种数据库切换，其中也参考了一些网上的东西，如果有版权问题，请私下联系我处理，项目比较简单，对入门还是有一定帮助的，大神请绕道。

正文

 1、先看SqlServer数据处理部分

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using System.Data.Common;

namespace DrugShop.Date.SqlServer
{
    internal class DataAccessUtil
    {
        /// <summary>
        /// 返回上次操作的第一行、第一列
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="paramList"></param>
        /// <param name="conn"></param>
        /// <returns></returns>
        public static object ExecuteScalar(string sql, List<SqlParameter> paramList, SqlConnection  conn)
        {
            if (conn.State!=ConnectionState.Open)
            {
                conn.Open();
            }
            SqlCommand cmd = conn.CreateCommand();
            cmd.CommandText = sql;
            cmd.Parameters.AddRange(paramList.ToArray());
            return cmd.ExecuteScalar();
        }
        /// <summary>
        /// 返回上次操作的第一行、第一列
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="paramList"></param>
        /// <param name="trans"></param>
        /// <returns></returns>
        public static object ExecuteScalar(string sql, List<SqlParameter> paramList, SqlTransaction trans)
        {
            SqlCommand cmd = trans.Connection.CreateCommand();
            cmd.Transaction = trans;
            cmd.CommandText = sql;
            cmd.Parameters.AddRange(paramList.ToArray());
            return cmd.ExecuteScalar();
        }
        #region 执行非查询式数据库操作
        
        /// <summary>
        /// 执行传入连接的非查询SQL语句
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="paramList"></param>
        /// <param name="conn"></param>
        public static void ExecuteNonQuery(string sql, List<SqlParameter> paramList,SqlConnection conn)
        {
            ExecuteNonQuery(sql, paramList, CommandType.Text,conn);
        }
       
        /// <summary>
        /// 执行传入连接的非查询SQL语句或存储过程
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="paramList"></param>
        /// <param name="type"></param>
        /// <param name="conn"></param>
        public static void ExecuteNonQuery(string sql, List<SqlParameter> paramList, CommandType type, SqlConnection conn)
        {
            if (conn.State!=ConnectionState.Open)
            {
                conn.Open();
            }
            SqlCommand cmd = conn.CreateCommand();
            cmd.CommandText = sql;
            cmd.CommandType = type;
            cmd.Parameters.AddRange(paramList.ToArray());
            cmd.ExecuteNonQuery();
        }
        /// <summary>
        /// 支持事物的非查询式SQL或存储过程
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="paramList"></param>
        /// <param name="trans"></param>
        public static void ExecuteNonQuery(string sql, List<SqlParameter> paramList, SqlTransaction trans)
        {
            ExecuteNonQuery(sql, paramList, CommandType.Text, trans);
        }
        
        /// <summary>
        /// 支持事物的非查询式SQL或存储过程
        /// </summary>
        /// <param name="sqlProcedure"></param>
        /// <param name="paramList"></param>
        /// <param name="type"></param>
        /// <param name="trans"></param>
        public static void ExecuteNonQuery(string sqlProcedure, List<SqlParameter> paramList, CommandType type, SqlTransaction trans)
        {
            SqlCommand cmd = trans.Connection.CreateCommand();
            cmd.Transaction = trans;
            cmd.CommandText = sqlProcedure;
            cmd.Parameters.AddRange(paramList.ToArray());
            cmd.CommandType = type;
            cmd.ExecuteNonQuery();
        }
        
        public static void ExecuteNonQuery(string sqlProcedure, List<SqlParameter> paramList, CommandType type, SqlConnection conn,SqlTransaction trans)
        {
            SqlCommand cmd = trans.Connection.CreateCommand();
            cmd.Transaction = trans;
            cmd.CommandText = sqlProcedure;
            cmd.Parameters.AddRange(paramList.ToArray());
            cmd.CommandType = type;
            cmd.ExecuteNonQuery();
        }
        #endregion
        #region 执行查询式数据库操作
        /// <summary>
        ///执行查询式SQL语句
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="paramList"></param>
        /// <returns></returns>
        public static SqlDataReader ExecuteReader(string sql, List<SqlParameter> paramList,SqlConnection conn)
        {
            return ExecuteReader(sql, paramList, CommandType.Text,conn);
        }
        /// <summary>
        /// 执行查询式SQL语句或者存储过程
        /// </summary>
        /// <param name="sqlOrProcedure"></param>
        /// <param name="paramList"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public static SqlDataReader ExecuteReader(string sqlOrProcedure, List<SqlParameter> paramList, CommandType type,SqlConnection conn)
        {
            if (conn.State!=ConnectionState.Open)
            {
                conn.Open();
            }
            SqlCommand cmd = conn.CreateCommand();
            cmd.CommandText = sqlOrProcedure;
            cmd.Parameters.AddRange(paramList.ToArray());
            cmd.CommandType = type;
            return cmd.ExecuteReader(CommandBehavior.CloseConnection);
        }
        public static SqlDataReader ExecuteReader(string sql, List<SqlParameter> paramList, SqlTransaction trans)
        {
            SqlConnection conn = trans.Connection;
            SqlCommand cmd = conn.CreateCommand();
            cmd.Transaction = trans;
            cmd.CommandText = sql;
            cmd.Parameters.AddRange(paramList.ToArray());
            return cmd.ExecuteReader();
        }
        public static DataSet ExecuteDataSet(string sql, List<SqlParameter> paramList,SqlConnection conn)
        {
            return ExecuteDataSet(sql, paramList, CommandType.Text,conn);
        }
        public static DataSet ExecuteDataSet(string sqlOrProcedure, List<SqlParameter> paramList, CommandType type,SqlConnection conn)
        {
            if (conn.State!=ConnectionState.Open )
            {
                conn.Open();
            }
            SqlCommand cmd = conn.CreateCommand();
            cmd.CommandText = sqlOrProcedure;
            cmd.Parameters.AddRange(paramList.ToArray());
            cmd.CommandType = type;
            DataSet ds = new DataSet();
            SqlDataAdapter adapter = new SqlDataAdapter(cmd);
            adapter.Fill(ds);
            return ds;
        }
        public static DataTable ExecuteDataTable(string sql, List<SqlParameter> paramList,SqlConnection conn)
        {
            return ExecuteDataTable(sql, paramList, CommandType.Text,conn);
        }
        public static DataTable ExecuteDataTable(string sqlOrProcedure, List<SqlParameter> paramList, CommandType type,SqlConnection conn)
        {
            if (conn.State!=ConnectionState.Open)
            {
                conn.Open();
            }
            SqlCommand cmd = conn.CreateCommand();
            cmd.CommandText = sqlOrProcedure;
            cmd.Parameters.AddRange(paramList.ToArray());
            cmd.CommandType = type;
            DataTable dt = new DataTable();
            SqlDataAdapter adapter = new SqlDataAdapter(cmd);
            adapter.Fill(dt);
            return dt;
        }
        #endregion
    }
}

其他的数据库就不写了，因为只实现了Sql Server部分，只是设计上可以支持数据库类型的切换，实际上并没有实现，其他的数据库可以参考SqlServer的代码实现。

2、通过工厂模式来打开不同的数据库

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Configuration;

namespace DrugShop.Date
{
    public class DAOFactory
    {
        private enum DatabaseType
        {
            SqlServer,
            MySql,
            Oracole,
            DB2,
            Postgre,
            SQLite
        }
        private DatabaseType _DbType;
        private string _ProviderName;
        private string _ConnectionString;
        private DAOFactory()
        {
            try
            {
                string connKey = "Dbconn";
                _ProviderName = ConfigurationManager.ConnectionStrings[connKey].ProviderName;
                _ConnectionString = ConfigurationManager.ConnectionStrings[connKey].ConnectionString;
                if (_ProviderName == "System.Data.SqlClient")
                {
                    _DbType = DatabaseType.SqlServer;
                }
                else if (_ProviderName == "System.Data.Oracole")
                {
                    _DbType = DatabaseType.Oracole;
                }
                else if (_ProviderName == "System.Data.MySql")
                {
                    _DbType = DatabaseType.MySql;
                }
                else if (_ProviderName == "System.Data.DB2")
                {
                    _DbType = DatabaseType.DB2;
                }
                else if (_ProviderName == "System.Data.Postgre")
                {
                    _DbType = DatabaseType.Postgre;
                }
                else if (_ProviderName == "System.Data.SQLite")
                {
                    _DbType = DatabaseType.SQLite;
                }
            }
            catch (Exception)
            {
                throw new ApplicationException("读取数据库配置文件错误，获取数据库文件失败。");
            }
            

        }
        private static DAOFactory _Instance=null;
        public static DAOFactory Instance
        {
            get {
                if (_Instance==null)
                {
                    _Instance = new DAOFactory();
                }
                return _Instance;
            }
        }
        public IEventLogDAO CreateEventLogDAO()
        {
            IEventLogDAO dao = null;
            if (_DbType==DatabaseType.SqlServer )
            {
                dao = new SqlServer.EventLogDAO();
            }
            else if (_DbType == DatabaseType.MySql)
            {
                dao = new MySql.EventLogDAO();
            }
            else if (_DbType == DatabaseType.Oracole)
            {
                dao = new Oracle.EventLogDAO();
            }
            else if (_DbType == DatabaseType.DB2)
            {
                dao = new DB2.EventLogDAO();
            }
            else if (_DbType == DatabaseType.Postgre)
            {
                dao = new Postgre.EventLogDAO();
            }
            return dao;
        }
        public IBillsDAO CreateBillsDAO()
        {
            IBillsDAO dao = null;
            if (_DbType == DatabaseType.SqlServer)
            {
                dao = new SqlServer.BillsDAO();
            }
            else if (_DbType == DatabaseType.MySql)
            {
                dao = new MySql.BillsDAO();
            }
            else if (_DbType == DatabaseType.Oracole)
            {
                dao = new Oracole.BillsDAO();
            }
            else if (_DbType == DatabaseType.DB2)
            {
                dao = new DB2.BillsDAO();
            }
            else if (_DbType == DatabaseType.Postgre)
            {
                dao = new Postgre.BillsDAO();
            }
            return dao;
        }
        public IBillsTypeDAO CreateBillsTypeDAO()
        {
            IBillsTypeDAO dao = null;
            if (_DbType == DatabaseType.SqlServer)
            {
                dao = new SqlServer.BillsTypeDAO();
            }
            else if (_DbType == DatabaseType.MySql)
            {
                dao = new MySql.BillsTypeDAO();
            }
            else if (_DbType == DatabaseType.Oracole)
            {
                dao = new Oracole.BillsTypeDAO();
            }
            else if (_DbType == DatabaseType.DB2)
            {
                dao = new DB2.BillsTypeDAO();
            }
            else if (_DbType == DatabaseType.Postgre)
            {
                dao = new Postgre.BillsTypeDAO();
            }
            return dao;
        }
        public ICompanyDAO CreateCompanyDAO()
        {
            ICompanyDAO dao = null;
            if (_DbType == DatabaseType.SqlServer)
            {
                dao = new SqlServer.CompanyDAO();
            }
            else if (_DbType == DatabaseType.MySql)
            {
                dao = new MySql.CompanyDAO();
            }
            else if (_DbType == DatabaseType.Oracole)
            {
                dao = new Oracole.CompanyDAO();
            }
            else if (_DbType == DatabaseType.DB2)
            {
                dao = new DB2.CompanyDAO();
            }
            else if (_DbType == DatabaseType.Postgre)
            {
                dao = new Postgre.CompanyDAO();
            }
            return dao;
        }
        public ICompanyTypeDAO CreateCompanyTypeDAO()
        {
            ICompanyTypeDAO dao = null;
            if (_DbType == DatabaseType.SqlServer)
            {
                dao = new SqlServer.CompanyTypeDAO();
            }
            else if (_DbType == DatabaseType.MySql)
            {
                dao = new MySql.CompanyTypeDAO();
            }
            else if (_DbType == DatabaseType.Oracole)
            {
                dao = new Oracole.CompanyTypeDAO();
            }
            else if (_DbType == DatabaseType.DB2)
            {
                dao = new DB2.CompanyTypeDAO();
            }
            else if (_DbType == DatabaseType.Postgre)
            {
                dao = new Postgre.CompanyTypeDAO();
            }
            return dao;
        }
        public IDrugCategoryDAO CreateDrugCategoryDAO()
        {
            IDrugCategoryDAO dao = null;
            if (_DbType == DatabaseType.SqlServer)
            {
                dao = new SqlServer.DrugCategoryDAO();
            }
            else if (_DbType == DatabaseType.MySql)
            {
                dao = new MySql.DrugCategoryDAO();
            }
            else if (_DbType == DatabaseType.Oracole)
            {
                dao = new Oracole.DrugCategoryDAO();
            }
            else if (_DbType == DatabaseType.DB2)
            {
                dao = new DB2.DrugCategoryDAO();
            }
            else if (_DbType == DatabaseType.Postgre)
            {
                dao = new Postgre.DrugCategoryDAO();
            }
            return dao;
        }
        public IDrugFromDAO CreateDrugFromDAO()
        {
            IDrugFromDAO dao = null;
            if (_DbType == DatabaseType.SqlServer)
            {
                dao = new SqlServer.DrugFromDAO();
            }
            else if (_DbType == DatabaseType.MySql)
            {
                dao = new MySql.DrugFromDAO();
            }
            else if (_DbType == DatabaseType.Oracole)
            {
                dao = new Oracole.DrugFromDAO();
            }
            else if (_DbType == DatabaseType.DB2)
            {
                dao = new DB2.DrugFromDAO();
            }
            else if (_DbType == DatabaseType.Postgre)
            {
                dao = new Postgre.DrugFromDAO();
            }
            return dao;
        }
        public IDrugsDAO CreateDrugsDAO()
        {
            IDrugsDAO dao = null;
            if (_DbType == DatabaseType.SqlServer)
            {
                dao = new SqlServer.DrugsDAO();
            }
            else if (_DbType == DatabaseType.MySql)
            {
                dao = new MySql.DrugsDAO();
            }
            else if (_DbType == DatabaseType.Oracole)
            {
                dao = new Oracole.DrugsDAO();
            }
            else if (_DbType == DatabaseType.DB2)
            {
                dao = new DB2.DrugsDAO();
            }
            else if (_DbType == DatabaseType.Postgre)
            {
                dao = new Postgre.DrugsDAO();
            }
            return dao;
        }
        public IResourceDAO CreateResourceDAO()
        {
            IResourceDAO dao = null;
            if (_DbType == DatabaseType.SqlServer)
            {
                dao = new SqlServer.ResourceDAO();
            }
            else if (_DbType == DatabaseType.MySql)
            {
                dao = new MySql.ResourceDAO();
            }
            else if (_DbType == DatabaseType.Oracole)
            {
                dao = new Oracole.ResourceDAO();
            }
            else if (_DbType == DatabaseType.DB2)
            {
                dao = new DB2.ResourceDAO();
            }
            else if (_DbType == DatabaseType.Postgre)
            {
                dao = new Postgre.ResourceDAO();
            }
            return dao;
        }
        public IStockDAO CreateStockDAO()
        {
            IStockDAO dao = null;
            if (_DbType == DatabaseType.SqlServer)
            {
                dao = new SqlServer.StockDAO();
            }
            else if (_DbType == DatabaseType.MySql)
            {
                dao = new MySql.StockDAO();
            }
            else if (_DbType == DatabaseType.Oracole)
            {
                dao = new Oracole.StockDAO();
            }
            else if (_DbType == DatabaseType.DB2)
            {
                dao = new DB2.StockDAO();
            }
            else if (_DbType == DatabaseType.Postgre)
            {
                dao = new Postgre.StockDAO();
            }
            return dao;
        }
        public IStorehouseDAO CreateStorehouseDAO()
        {
            IStorehouseDAO dao = null;
            if (_DbType == DatabaseType.SqlServer)
            {
                dao = new SqlServer.StorehouseDAO();
            }
            else if (_DbType == DatabaseType.MySql)
            {
                dao = new MySql.StorehouseDAO();
            }
            else if (_DbType == DatabaseType.Oracole)
            {
                dao = new Oracole.StorehouseDAO();
            }
            else if (_DbType == DatabaseType.DB2)
            {
                dao = new DB2.StorehouseDAO();
            }
            else if (_DbType == DatabaseType.Postgre)
            {
                dao = new Postgre.StorehouseDAO();
            }
            return dao;
        }
        public IUserDAO CreateUserDAO()
        {
            IUserDAO dao = null;
            if (_DbType == DatabaseType.SqlServer)
            {
                dao = new SqlServer.UserDAO();
            }
            else if (_DbType == DatabaseType.MySql)
            {
                dao = new MySql.UserDAO();
            }
            else if (_DbType == DatabaseType.Oracole)
            {
                dao = new Oracole.UserDAO();
            }
            else if (_DbType == DatabaseType.DB2)
            {
                dao = new DB2.UserDAO();
            }
            else if (_DbType == DatabaseType.Postgre)
            {
                dao = new Postgre.UserDAO();
            }
            return dao;
        }
        public IDbConnection OpenConnection()
        {
            IDbConnection conn = System.Data.Common.DbProviderFactories.GetFactory(_ProviderName).CreateConnection();
            conn.ConnectionString = _ConnectionString;
            conn.Open();
            return conn;
        }
    }
}

 3、调用方式

#region 药品
        /// <summary>
        /// 增加一个药品信息
        /// </summary>
        /// <param name="drug"></param>
        /// <param name="creator"></param>
        public void CreateDrug(Drugs drug,string creator)
        {
            using (IDbConnection conn=DAOFactory.Instance.OpenConnection())
            {
                IDrugsDAO dao = DAOFactory.Instance.CreateDrugsDAO();
                dao.InsertDrug(drug,conn);
            }
        }
        /// <summary>
        /// 保存修改过的药品信息
        /// </summary>
        /// <param name="drug"></param>
        /// <param name="Modifier"></param>
        public void SaveDrug(Drugs drug,string Modifier)
        {
            using (IDbConnection conn=DAOFactory.Instance.OpenConnection())
            {
                IDrugsDAO dao = DAOFactory.Instance.CreateDrugsDAO();
                dao.UpdateDrug(drug ,conn );
            }
        }
        /// <summary>
        /// 删除一个药品信息
        /// </summary>
        /// <param name="drug"></param>
        /// <param name="Deleter"></param>
        public void DeleteDrug(Drugs drug, string Deleter)
        {
            using (IDbConnection conn=DAOFactory.Instance.OpenConnection())
            {
                IDrugsDAO dao = DAOFactory.Instance.CreateDrugsDAO();
                dao.DeleteDrug(drug.ID,conn);
            }
        }
        /// <summary>
        /// 获取所有药品信息
        /// </summary>
        /// <returns></returns>
        public List<Drugs> GetAllDrugs()
        {
            using (IDbConnection conn=DAOFactory.Instance.OpenConnection())
            {
                IDrugsDAO dao = DAOFactory.Instance.CreateDrugsDAO();
                return dao.SelectAllDrugs(conn);
            }
        }
        /// <summary>
        /// 根据ID查找一个药品信息
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public Drugs RetrieveDrug(int id)
        {
            using (IDbConnection conn=DAOFactory.Instance.OpenConnection())
            {
                IDrugsDAO dao = DAOFactory.Instance.CreateDrugsDAO();
                return dao.SelectDrug(id,conn);
            }
        }
        /// <summary>
        /// 获取指定编码的药品
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public Drugs GetDrugsByCode(string code)
        {
            using (IDbConnection conn=DAOFactory.Instance.OpenConnection())
            {
                IDrugsDAO dao = DAOFactory.Instance.CreateDrugsDAO();
                return dao.SelectDrug(code,conn);
            }
        }
        /// <summary>
        /// 根据条件进行模糊搜索
        /// </summary>
        /// <param name="searchCond">搜索条件</param>
        /// <returns></returns>
        public List<Drugs> SearchDrugs(string searchCond)
        {
            using (IDbConnection conn = DAOFactory.Instance.OpenConnection())
            {
                IDrugsDAO dao = DAOFactory.Instance.CreateDrugsDAO();
                SearchDrugsTemplate template = new SearchDrugsTemplate();
                template.Code = searchCond;
                template.Name = searchCond;
                template.From = searchCond;
                template.Category = searchCond;
                return dao.SearchDrugs(template, conn);
            }
        }
        #endregion

 结尾

因为当时水平很菜，所以这个设计的也存在一些问题，后面发现动软代码生成器生成的架构采用了抽象工厂模式，耦合度更低。