万能的SqlHelper，麻麻再也不用担心用什么数据库了

以前只用一种数据库，倒也无所谓，但是再数据库切换的时候，发现代码差不多呀。

最初，两种数据库，大不了写两个SqlHelper，但是多了也就发现代码重用率太低了吧。

因此，下面的SqlHelper诞生了。

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

namespace WangSql.DBUtility
{
    public static class SqlHelperExt
    {
        public static int AddRange(this IDataParameterCollection coll, IDataParameter[] par)
        {
            int i = ;
            foreach (var item in par)
            {
                coll.Add(item);
                i++;
            }
            return i;
        }
    }

    #region SqlHelper
    public class SqlHelper
    {
        private IDbConnection conn = null;
        private IDbCommand cmd = null;
        private IDataReader dr = null;
        private DbType type = DbType.NONE;

        #region 创建数据库连接
        /// <summary>
        /// 创建数据库连接
        /// </summary>
        public SqlHelper(string connectionString)
        {
            conn = DBFactory.CreateDbConnection(type, connectionString);
        }
        #endregion

        #region 判断并打开conn
        /// <summary>
        /// 判断并打开conn
        /// </summary>
        /// <returns></returns>
        public IDbConnection CreatConn()
        {
            if (conn.State == ConnectionState.Closed)
            {
                conn.Open();
            }
            return conn;
        }
        #endregion

        #region 执行查询sql语句
        /// <summary>
        /// 执行查询sql语句
        /// </summary>
        /// <param name="sql">查询sql语句</param>
        /// <returns>返回一个表</returns>
        public DataTable ExecuteReader(string sql)
        {
            DataTable dt = new DataTable();
            using (cmd = DBFactory.CreateDbCommand(sql, CreatConn()))
            {
                using (dr = cmd.ExecuteReader())
                {
                    dt.Load(dr);
                }
            }
            conn.Close();
            return dt;
        }
        #endregion

        #region 执行查询带参的sql语句
        /// <summary>
        /// 执行查询带参的sql语句
        /// </summary>
        /// <param name="sql">查询sql语句</param>
        /// <param name="par">sql语句中的参数</param>
        /// <returns>返回一个表</returns>
        public DataTable ExecuteReader(string sql, IDataParameter[] par)
        {
            DataTable dt = new DataTable();
            using (cmd = DBFactory.CreateDbCommand(sql, CreatConn()))
            {
                cmd.Parameters.AddRange(par);
                using (dr = cmd.ExecuteReader())
                {
                    dt.Load(dr);
                }
            }
            conn.Close();
            return dt;
        }
        public DataTable ExecuteReader(string sql, IDataParameter par)
        {
            DataTable dt = new DataTable();
            using (cmd = DBFactory.CreateDbCommand(sql, CreatConn()))
            {
                cmd.Parameters.Add(par);
                using (dr = cmd.ExecuteReader())
                {
                    dt.Load(dr);
                }
            }
            conn.Close();
            return dt;
        }
        #endregion

        #region 执行增，删，改sql语句
        /// <summary>
        /// 执行无参的增，删，改sql语句
        /// </summary>
        /// <param name="sql">增，删，改的sql语句</param>
        /// <param name="par">sql语句中的参数</param>
        /// <returns>返回所影响的行数</returns>
        public int ExecuteNonQuery(string sql)
        {
            int result = ;
            using (cmd = DBFactory.CreateDbCommand(sql, CreatConn()))
            {
                result = cmd.ExecuteNonQuery();
            }
            conn.Close();
            return result;
        }
        #endregion

        #region 执行带参的增，删，改sql语句
        /// <summary>
        /// 执行带参的增，删，改sql语句
        /// </summary>
        /// <param name="sql">增，删，改的sql语句</param>
        /// <param name="par">sql语句中的参数</param>
        /// <returns>返回所影响的行数</returns>
        public int ExecuteNonQuery(string sql, IDbDataParameter[] par)
        {
            int result = ;
            using (cmd = DBFactory.CreateDbCommand(sql, CreatConn()))
            {
                cmd.Parameters.AddRange(par);
                result = cmd.ExecuteNonQuery();
            }
            conn.Close();
            return result;
        }
        public int ExecuteNonQuery(string sql, IDbDataParameter par)
        {
            int result = ;
            using (cmd = DBFactory.CreateDbCommand(sql, CreatConn()))
            {
                cmd.Parameters.Add(par);
                result = cmd.ExecuteNonQuery();
            }
            conn.Close();
            return result;
        }
        #endregion

        #region 事务
        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLList">SQL语句的哈希表（key为sql语句，value是该语句的OleDbParameter[]）</param>
        public bool ExecuteTransaction(Hashtable SqlList)
        {
            CreatConn();
            using (IDbTransaction trans = conn.BeginTransaction())
            {
                IDbCommand cmd = DBFactory.CreateDbCommand(type);
                try
                {
                    //循环
                    foreach (DictionaryEntry myDE in SqlList)
                    {
                        string cmdText = myDE.Key.ToString();
                        IDbDataParameter[] cmdParms = (IDbDataParameter[])myDE.Value;
                        PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                        int val = cmd.ExecuteNonQuery();
                        cmd.Parameters.Clear();
                    }
                    trans.Commit();
                }
                catch
                {
                    trans.Rollback();
                    return false;
                }
                finally
                {
                    conn.Close();
                }
            }
            return true;
        }

        private void PrepareCommand(IDbCommand cmd, IDbConnection conn, IDbTransaction trans, string cmdText, IDataParameter[] cmdParms)
        {
            CreatConn();
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            if (trans != null)
                cmd.Transaction = trans;
            cmd.CommandType = CommandType.Text;//cmdType;
            if (cmdParms != null)
                cmd.Parameters.AddRange(cmdParms);
        }
        #endregion
    }
    #endregion
}

上面是核心代码，上面有个扩展。主要是是由于抽象类里面不包含AddRange方法。楼主也是懒得改原来的方法，也是为了和原来的SqlHelper保持一致，干脆就直接扩展了一个AddRange。

好了，既然是全是抽象参数，实际中，还是需要实例化具体某种数据库的实例的，所以还需要一个创建各个数据库实例的工厂了。

using MySql.Data.MySqlClient;
using Oracle.DataAccess.Client;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.OleDb;
using System.Data.SqlClient;
using System.Data.SQLite;
using System.Linq;
using System.Text;

namespace WangSql
{
    public enum DbType
    {
        //Oracle,SqlServer,MySql,Access,SqlLite
        NONE,
        ORACLE,
        SQLSERVER,
        MYSQL,
        ACCESS,
        SQLLITE
    }

    public class DBFactory
    {
        public static IDbConnection CreateDbConnection(DbType type, string connectionString)
        {
            IDbConnection conn = null;
            switch (type)
            {
                case DbType.ORACLE:
                    conn = new OracleConnection(connectionString);
                    break;
                case DbType.SQLSERVER:
                    conn = new SqlConnection(connectionString);
                    break;
                case DbType.MYSQL:
                    conn = new MySqlConnection(connectionString);
                    break;
                case DbType.ACCESS:
                    conn = new OleDbConnection(connectionString);
                    break;
                case DbType.SQLLITE:
                    conn = new SQLiteConnection(connectionString);
                    break;
                case DbType.NONE:
                    throw new Exception("未设置数据库类型");
                default:
                    throw new Exception("不支持该数据库类型");
            }
            return conn;
        }

        public static IDbCommand CreateDbCommand(DbType type)
        {
            IDbCommand cmd = null;
            switch (type)
            {
                case DbType.ORACLE:
                    cmd = new OracleCommand();
                    break;
                case DbType.SQLSERVER:
                    cmd = new SqlCommand();
                    break;
                case DbType.MYSQL:
                    cmd = new MySqlCommand();
                    break;
                case DbType.ACCESS:
                    cmd = new OleDbCommand();
                    break;
                case DbType.SQLLITE:
                    cmd = new SQLiteCommand();
                    break;
                case DbType.NONE:
                    throw new Exception("未设置数据库类型");
                default:
                    throw new Exception("不支持该数据库类型");
            }
            return cmd;
        }
        public static IDbCommand CreateDbCommand(string sql, IDbConnection conn)
        {
            DbType type = DbType.NONE;
            if (conn is OracleConnection)
                type = DbType.ORACLE;
            else if (conn is SqlConnection)
                type = DbType.SQLSERVER;
            else if (conn is MySqlConnection)
                type = DbType.MYSQL;
            else if (conn is OleDbConnection)
                type = DbType.ACCESS;
            else if (conn is SQLiteConnection)
                type = DbType.SQLLITE;

            IDbCommand cmd = null;
            switch (type)
            {
                case DbType.ORACLE:
                    cmd = new OracleCommand(sql, (OracleConnection)conn);
                    break;
                case DbType.SQLSERVER:
                    cmd = new SqlCommand(sql, (SqlConnection)conn);
                    break;
                case DbType.MYSQL:
                    cmd = new MySqlCommand(sql, (MySqlConnection)conn);
                    break;
                case DbType.ACCESS:
                    cmd = new OleDbCommand(sql, (OleDbConnection)conn);
                    break;
                case DbType.SQLLITE:
                    cmd = new SQLiteCommand(sql, (SQLiteConnection)conn);
                    break;
                case DbType.NONE:
                    throw new Exception("未设置数据库类型");
                default:
                    throw new Exception("不支持该数据库类型");
            }
            return cmd;
        }

    }
}

哈哈，即使再来一个数据库，你试试看，是不是很简单呢。

对了，上面的SqlHelper再单例模式下是有问题的哦，这个请大家提出下好的建议。