asp.net下使用ado.net打造通用的數據庫操作類

原文地址：http://www.cnblogs.com/lifeil/archive/2013/04/16/3024161.html 

在上一個項目中一直使用動軟生成的數據庫操作類，我們的項目不是很大，對ORM這類龐大的框架不太合適。因此，我們還是使用原生的ado.net來操作數據庫。后來發現，動軟生成的數據庫操作類在某些方法上不太順手，內部方法命名也有些混亂。

偶爾在CSDN上看到周公寫的數據庫通用操作類，豁然開朗，他的數據庫操作通用類采用了工廠設計模式，通過System.Data.Common命名空間下的對象和自定義的工廠類實現了對多種數據庫的操作。

想來數據庫操作在一個項目中是自始至終的，於是就寫成了單例模式。經過修改現貼出來。

數據庫操作核心類如下：

    /// <summary>
    /// 單例模式實例化數據庫操作輔助類
    /// </summary>
    public class DbUtility
    {

        #region 私有字段

        private static readonly string connectionString = ConfigurationManager.AppSettings["MSSQLConnectionString"];
        private readonly DbProviderFactory providerFactory;
 
        #endregion

        #region 公共字段
        /// <summary>
        /// 獲取 Web.config文件中配置的 MSSQL 連接的字符串
        /// </summary>
        public string ConnectionString
        {
            get;
            private set;
        }
        #endregion

        #region 創建通用數據庫操作類的單一實例

        static volatile DbUtility instance = null;
        static readonly object padlock = new object();

        /// <summary>
        /// 單例模式實例化數據庫操作通用類
        /// </summary>
        private DbUtility() 
        {
            ConnectionString = connectionString;
            providerFactory = ProviderFactory.GetDbProviderFactory(DbProviderType.SqlServer);
            if (providerFactory == null)
            {
                throw new ArgumentException("Can't load DbProviderFactory for given value of providerType");
            }
        }
        /// <summary>
        /// 單例模式實例化數據庫操作通用類
        /// </summary>
        /// <param name="connectionString">數據庫連接字符串</param>
        /// <param name="providerType">數據庫類型枚舉</param>
        private DbUtility(string connectionString, DbProviderType providerType)
        {
            ConnectionString = connectionString;
            providerFactory = ProviderFactory.GetDbProviderFactory(providerType);
            if (providerFactory == null)
            {
                throw new ArgumentException("Can't load DbProviderFactory for given value of providerType");
            }
        }

        /// <summary>
        /// 創建MSSQL數據庫操作通用類的單一實例
        /// </summary>
        /// <returns>獲取<see cref="LiFeiLin.DBUtility.DbUtility"/>的實例</returns>
        public static DbUtility GetInstance() 
        {
            return GetInstance(connectionString, DbProviderType.SqlServer);
        }
        /// <summary>
        /// 創建通用數據庫操作類的單一實例
        /// </summary>
        /// <param name="connectionString">數據庫連接字符串</param>
        /// <param name="providerType">數據庫類型枚舉</param>
        /// <returns>獲取<see cref="LiFeiLin.DBUtility.DbUtility"/>的實例</returns>
        public static DbUtility GetInstance(string connectionString,DbProviderType providerType)
        {
            if (instance == null)
            {

                lock (padlock)
                {

                    if (instance == null)
                    {
                        instance = new DbUtility(connectionString, providerType);
                    }
                }
            }
            return instance;
        }
        #endregion

        #region 獲取某個表的記錄數量
        /// <summary>
        /// 獲取某個表的記錄數量
        /// </summary>
        /// <param name="tableName"></param>
        /// <returns></returns>
        public int GetDataRecordCount(string tableName)
        {
            return GetDataRecordCount(tableName);
        }
        /// <summary>   
        /// 獲取某個表的記錄數量   
        /// </summary>   
        /// <param name="tableName">表名</param>   
        /// <param name="where">條件</param>   
        /// <returns></returns>   
        public int GetDataRecordCount(string tableName, string where)
        {
            string strsql = "select count(1) from " + tableName;
            if (where != "")
            {
                strsql += " where " + where;
            }
            object obj = ExecuteScalar(strsql);
            if (obj == null)
            {
                return 1;
            }
            else
            {
                return int.Parse(obj.ToString());
            }
        }  
        #endregion

        #region 獲取指定表中指定列的最大值
        /// <summary>
        /// 獲取指定表中指定列的最大值
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="tableName">表名</param>
        /// <returns></returns>
        public int GetMaxID(string fieldName, string tableName)
        {
            string strsql = "select max(" + fieldName + ")+1 from " + tableName;
            object obj = ExecuteScalar(strsql);
            if (obj == null)
            {
                return 1;
            }
            else
            {
                return int.Parse(obj.ToString());
            }
        } 

        #endregion

        #region 執行一個查詢 SQL 語句，並根據返回值判斷執行結果是否存在
        /// <summary>
        /// 執行一個查詢 SQL 語句，並根據返回值判斷執行結果是否存在
        /// </summary>
        /// <param name="strSql"></param>
        /// <returns></returns>
        public bool Exists(string strSql)
        {
            object obj = ExecuteScalar(strSql);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        /// <summary>
        /// 執行一個查詢 SQL 語句，並根據返回值判斷執行結果是否存在
        /// </summary>
        /// <param name="strSql">需要執行的 SQL 查詢語句</param>
        /// <param name="cmdParms">結構化參數數組</param>
        /// <returns></returns>
        public bool Exists(string strSql, params DbParameter[] cmdParms)
        {
            object obj = ExecuteScalar(strSql, cmdParms);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        /// <summary>
        /// 表是否存在
        /// </summary>
        /// <param name="tableName">表名</param>
        /// <returns></returns>
        public bool TabExists(string tableName)
        {
            string strsql = "select count(*) from sysobjects where id = object_id(N'[" + tableName + "]') and OBJECTPROPERTY(id, N'IsUserTable') = 1";
            object obj = ExecuteScalar(strsql);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        #endregion

        #region 執行多條SQL語句，實現數據庫事務

        /// <summary>   
        /// 執行多條SQL語句，實現數據庫事務。   
        /// </summary>   
        /// <param name="sqlStringList">SQL語句的哈希表（key為sql語句，value是該語句的SqlParameter[]）</param>   
        public void ExecuteSqlTran(Hashtable sqlStringList)
        {
            using (DbConnection connection = providerFactory.CreateConnection())
            {
                connection.Open();
                using(DbTransaction trans = connection.BeginTransaction())
                {
                    DbCommand command = null;
                    try
                    {
                        foreach (DictionaryEntry myDE in sqlStringList)
                        {
                            string cmdText = myDE.Key.ToString();
                            DbParameter[] cmdParms = (DbParameter[])myDE.Value;
                            CreateDbCommand(command, connection, trans, cmdText, cmdParms);
                            command.ExecuteNonQuery();
                            command.Parameters.Clear();
                        }
                        trans.Commit();
                    }
                    catch
                    {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }
        #endregion

        #region 執行一個查詢語句，返回一個關聯的DataReader實例
        /// <summary> 
        /// 執行一個查詢語句，返回一個關聯的DataReader實例
        /// </summary> 
        /// <param name="sqlString">要執行的查詢語句</param> 
        /// <returns></returns> 
        public DbDataReader ExecuteReader(string sqlString)
        {
            return ExecuteReader(sqlString, CommandType.Text, 0, null);
        }
        /// <summary>
        /// 執行一個查詢語句，返回一個關聯的DataReader實例
        /// </summary>
        /// <param name="sqlString">要執行的查詢語句</param>
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>
        /// <returns></returns>
        public DbDataReader ExecuteReader(string sqlString, DbParameter[] parameters)
        {
            return ExecuteReader(sqlString, CommandType.Text, 0, parameters);
        }
        /// <summary> 
        ///  執行一個查詢語句，返回一個關聯的DataReader實例     
        /// </summary> 
        /// <param name="sqlString">要執行的查詢語句</param> 
        /// <param name="commandType">要執行查詢語句的類型，如存儲過程或者SQl文本命令</param> 
        /// <returns></returns> 
        public DbDataReader ExecuteReader(string sqlString, CommandType commandType)
        {
            return ExecuteReader(sqlString, commandType,0, null);
        }

        /// <summary>   
        /// 執行一個查詢語句，返回一個關聯的DataReader實例     
        /// </summary>   
        /// <param name="sqlString">要執行的查詢語句</param>   
        /// <param name="times">超時時間</param>
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>
        /// <returns>SqlDataReader</returns>   
        public DbDataReader ExecuteReader(string sqlString,int times, params DbParameter[] parameters)
        {
            return ExecuteReader(sqlString, CommandType.Text, times, parameters);
        }

        /// <summary>     
        /// 執行一個查詢語句，返回一個關聯的DataReader實例     
        /// </summary>     
        /// <param name="sqlString">要執行的查詢語句</param>     
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>  
        /// <param name="commandType">執行的SQL語句的類型</param>  
        /// <param name="times">超時時間</param>
        /// <returns></returns>   
        public DbDataReader ExecuteReader(string sqlString, CommandType commandType,int times, DbParameter[] parameters)
        {
            DbCommand command = CreateDbCommand(sqlString, commandType,times, parameters);
            command.Connection.Open();
            return command.ExecuteReader(CommandBehavior.CloseConnection);
        }  
        #endregion

        #region 執行存儲過程
        /// <summary>   
        /// 執行存儲過程  (使用該方法切記要手工關閉SqlDataReader和連接)   
        /// </summary>   
        /// <param name="storedProcName">存儲過程名</param>   
        /// <param name="parameters">存儲過程參數</param>   
        /// <returns>SqlDataReader</returns>   
        public DbDataReader RunProcedure(string storedProcName, IDbDataParameter[] parameters)
        {
            DbConnection connection = providerFactory.CreateConnection();
            connection.ConnectionString = ConnectionString;
            DbDataReader returnReader;
            connection.Open();
            DbCommand command = CreateDbQueryCommand(connection, storedProcName, parameters);
            command.CommandType = CommandType.StoredProcedure;
            returnReader = command.ExecuteReader();
            //Connection.Close(); 不能在此關閉，否則，返回的對象將無法使用               
            return returnReader;
        }

        /// <summary>   
        /// 執行存儲過程   
        /// </summary>   
        /// <param name="storedProcName">存儲過程名</param>   
        /// <param name="parameters">存儲過程參數</param>   
        /// <param name="tableName">DataSet結果中的表名</param>   
        /// <returns>DataSet</returns>   
        public DataSet RunProcedure(string storedProcName, IDbDataParameter[] parameters, string tableName)
        {
            using (DbConnection connection = providerFactory.CreateConnection())
            {
                DataSet dataSet = new DataSet();
                connection.ConnectionString = ConnectionString;
                connection.Open();
                DbDataAdapter sqlDA = providerFactory.CreateDataAdapter();
                sqlDA.SelectCommand = CreateDbQueryCommand(connection, storedProcName, parameters);
                sqlDA.Fill(dataSet, tableName);
                connection.Close();
                return dataSet;
            }
        }
        /// <summary>   
        /// 執行存儲過程   
        /// </summary>   
        /// <param name="storedProcName">存儲過程名</param>   
        /// <param name="parameters">存儲過程參數</param>   
        /// <param name="tableName">DataSet結果中的表名</param> 
        /// <param name="times">儲存過程執行超時時間</param>
        /// <returns>DataSet</returns>   
        public DataSet RunProcedure(string storedProcName, IDbDataParameter[] parameters, string tableName, int times)
        {
            using (DbConnection connection = providerFactory.CreateConnection())
            {
                connection.ConnectionString = ConnectionString;
                DataSet dataSet = new DataSet();
                connection.Open();
                DbDataAdapter sqlDA = providerFactory.CreateDataAdapter();
                sqlDA.SelectCommand = CreateDbQueryCommand(connection, storedProcName, parameters);
                sqlDA.SelectCommand.CommandTimeout = times;
                sqlDA.Fill(dataSet, tableName);
                connection.Close();
                return dataSet;
            }
        }
        /// <summary>   
        /// 執行存儲過程后返回執行結果（標識）   
        /// </summary>   
        /// <param name="storedProcName">儲存過程名稱</param>   
        /// <param name="parameters">儲存過程參數</param>   
        /// <returns></returns>   
        public string RunProcedureState(string storedProcName, IDbDataParameter[] parameters)
        {
            using (DbConnection connection = providerFactory.CreateConnection())
            {
                connection.ConnectionString = ConnectionString;
                connection.Open();
                DbDataAdapter sqlDA = providerFactory.CreateDataAdapter();
                

                DbParameter parameter = providerFactory.CreateParameter();
                parameter.ParameterName = "ReturnValue";
                parameter.DbType = DbType.Int32;
                parameter.Size = 4;
                parameter.Direction = ParameterDirection.ReturnValue;
                parameter.SourceColumnNullMapping = false;
                parameter.SourceColumn = string.Empty;
                parameter.SourceVersion = DataRowVersion.Default;
                parameter.Value = null;

                sqlDA.SelectCommand = CreateDbQueryCommand(connection, storedProcName, parameters);

                sqlDA.SelectCommand.Parameters.Add(parameter); //增加存儲過程的返回值參數   
                sqlDA.SelectCommand.ExecuteNonQuery();
                connection.Close();
                return sqlDA.SelectCommand.Parameters["ReturnValue"].Value.ToString();
            }
        }

        
        /// <summary>   
        /// 執行存儲過程，返回影響的行數         
        /// </summary>   
        /// <param name="storedProcName">存儲過程名</param>   
        /// <param name="parameters">存儲過程參數</param>   
        /// <param name="rowsAffected">影響的行數</param>   
        /// <returns></returns>   
        public int RunProcedure(string storedProcName, IDbDataParameter[] parameters, out int rowsAffected)
        {
            using (DbConnection connection = providerFactory.CreateConnection())
            {
                connection.ConnectionString = ConnectionString;
                int result;
                connection.Open();
                DbCommand command = CreateDbCommand(connection, storedProcName, parameters);
                rowsAffected = command.ExecuteNonQuery();
                result = (int)command.Parameters["ReturnValue"].Value;
                return result;
            }
        }
        #endregion

        #region 執行查詢語句並返回DataSet
        /// <summary>   
        /// 執行查詢語句並返回 <see cref="System.Data.DataSet"/> 對象
        /// </summary>   
        /// <param name="sqlString">查詢語句</param>   
        /// <returns>DataSet</returns>   
        public DataSet ExecuteQuery(string sqlString)
        {
            return ExecuteQuery(sqlString, CommandType.Text, 0, null);
        }
        /// <summary>   
        ///執行查詢語句並返回 <see cref="System.Data.DataSet"/> 對象
        /// </summary>   
        /// <param name="sqlString"></param>   
        /// <param name="times"></param>   
        /// <returns></returns>   
        public DataSet ExecuteQuery(string sqlString, int times)
        {
            return ExecuteQuery(sqlString, CommandType.Text, times, null);
        }
        /// <summary>   
        /// 執行查詢語句並返回 <see cref="System.Data.DataSet"/> 對象
        /// </summary>   
        /// <param name="sqlString">查詢語句</param>   
        /// <param name="cmdParms">結構化參數</param>
        /// <returns>DataSet</returns>   
        public DataSet ExecuteQuery(string sqlString, DbParameter[] parameters)
        {
            return ExecuteQuery(sqlString, CommandType.Text, 0, parameters);
        }
        /// <summary>
        /// 執行查詢語句並返回 <see cref="System.Data.DataSet"/> 對象
        /// </summary>
        /// <param name="sqlString"></param>
        /// <param name="times"></param>
        /// <param name="cmdParms"></param>
        /// <returns></returns>
        public DataSet ExecuteQuery(string sqlString,CommandType commandType, int times, DbParameter[] parameters)
        {
            using (DbCommand command = CreateDbCommand(sqlString, commandType,times, parameters))
            {
                command.Connection.Open();
                using (DbDataAdapter da = providerFactory.CreateDataAdapter())
                {
                    da.SelectCommand = command;
                    DataSet ds = new DataSet();
                    da.Fill(ds, "ds");
                    command.Parameters.Clear();
                    command.Connection.Close();
                    return ds;
                }
            }  
        }
        #endregion

        #region 對數據庫執行增刪改操作，返回受影響的行數。
        /// <summary> 
        /// 對數據庫執行增刪改操作，返回受影響的行數。
        /// </summary> 
        /// <param name="sqlString">要執行的sql命令</param> 
        /// <returns></returns> 
        public int ExecuteNonQuery(string sqlString)
        {
            return ExecuteNonQuery(sqlString, CommandType.Text, 0, null);
        }
        /// <summary>
        /// 對數據庫執行增刪改操作，返回受影響的行數。
        /// </summary>
        /// <param name="sqlString">要執行的增刪改的SQL語句</param>
        /// <param name="times">超時時間</param>
        /// <returns></returns>
        public int ExecuteNonQuery(string sqlString, int times)
        {
            return ExecuteNonQuery(sqlString, CommandType.Text, times, null);
        }
        /// <summary>
        /// 對數據庫執行增刪改操作，返回受影響的行數。
        /// </summary>
        /// <param name="sqlString">要執行的增刪改的SQL語句</param>
        /// <param name="parameters">結構化的參數列表</param>
        /// <returns></returns>
        public int ExecuteNonQuery(string sqlString, DbParameter[] parameters)
        {
            return ExecuteNonQuery(sqlString, CommandType.Text, 0, parameters);
        }
        /// <summary> 
        /// 對數據庫執行增刪改操作，返回受影響的行數。
        /// </summary> 
        /// <param name="sqlString">要執行的增刪改的SQL語句</param> 
        /// <param name="commandType">要執行查詢語句的類型，如存儲過程或者sql文本命令</param> 
        /// <returns></returns> 
        public int ExecuteNonQuery(string sqlString, CommandType commandType)
        {
            return ExecuteNonQuery(sqlString, commandType, 0, null);
        }

        /// <summary>     
        /// 對數據庫執行增刪改操作，返回受影響的行數。     
        /// </summary>     
        /// <param name="sqlString">要執行的增刪改的SQL語句</param>    
        /// <param name="commandType">執行的SQL語句的類型</param>  
        /// <param name="times">超時時間</param>
        /// <param name="parameters">執行增刪改語句所需要的參數</param>  
        /// <returns></returns>  
        public int ExecuteNonQuery(string sqlString, CommandType commandType,int times, DbParameter[] parameters)
        {
            using (DbCommand command = CreateDbCommand(sqlString, commandType,times, parameters))
            {
                command.Connection.Open();
                int affectedRows = command.ExecuteNonQuery();
                command.Connection.Close();
                return affectedRows;
            }
        }  
        #endregion

        #region 執行一個查詢，返回結果集的首行首列。忽略其他行，其他列 
        /// <summary> 
        /// 執行一個查詢，返回結果集的首行首列。忽略其他行，其他列 
        /// </summary> 
        /// <param name="sqlString">要執行的SQl命令</param> 
        /// <returns></returns> 
        public Object ExecuteScalar(string sqlString)
        {
            return ExecuteScalar(sqlString, CommandType.Text, 0, null);
        }

        /// <summary> 
        ///  執行一個查詢，返回結果集的首行首列。忽略其他行，其他列 
        /// </summary> 
        /// <param name="sqlString">要執行的SQl命令</param> 
        /// <param name="times">執行超時時間</param> 
        /// <returns></returns> 
        public Object ExecuteScalar(string sqlString, int times)
        {
            return ExecuteScalar(sqlString, CommandType.Text, times, null);
        }
        /// <summary>
        /// 執行一個查詢，返回結果集的首行首列。忽略其他行，其他列 
        /// </summary>
        /// <param name="sqlString">要執行的SQl命令</param>
        /// <param name="cmdParms">結構化的查詢語句</param>
        /// <returns></returns>
        public object ExecuteScalar(string sqlString, params DbParameter[] cmdParms)
        {
            return ExecuteScalar(sqlString,CommandType.Text, 0, cmdParms);
        }

        /// <summary>     
        /// 執行一個查詢語句，返回查詢結果的第一行第一列     
        /// </summary>     
        /// <param name="sql">要執行的查詢語句</param>     
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>     
        /// <param name="commandType">執行的SQL語句的類型</param>  
        /// <returns></returns>     
        public Object ExecuteScalar(string sqlString, CommandType commandType, int times, DbParameter[] parameters)
        {
            using (DbCommand command = CreateDbCommand(sqlString, commandType, times, parameters))
            {
                command.Connection.Open();
                object result = command.ExecuteScalar();
                command.Connection.Close();
                return result;
            }
        } 
        #endregion

        #region 執行一個查詢語句，返回一個包含查詢結果的DataTable
        /// <summary> 
        /// 執行一個查詢語句，返回一個包含查詢結果的DataTable   
        /// </summary> 
        /// <param name="sql">要執行的sql文本命令</param> 
        /// <returns>返回查詢的結果集</returns> 
        public DataTable ExecuteDataTable(string sql)
        {
            return ExecuteDataTable(sql, CommandType.Text, 0, null);
        }
        /// <summary>
        /// 執行一個查詢語句，返回一個包含查詢結果的DataTable  
        /// </summary>
        /// <param name="sqlString">要執行的sql文本命令</param>
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>
        /// <returns></returns>
        public DataTable ExecuteDataTable(string sqlString, DbParameter[] parameters)
        {
            return ExecuteDataTable(sqlString, CommandType.Text, 0, parameters);
        }
        /// <summary> 
        /// 執行一個查詢語句，返回一個包含查詢結果的DataTable   
        /// </summary> 
        /// <param name="sqlString">要執行的sql語句</param> 
        /// <param name="commandType">要執行的查詢語句的類型，如存儲過程或者sql文本命令</param> 
        /// <returns>返回查詢結果集</returns> 
        public DataTable ExecuteDataTable(string sqlString, CommandType commandType)
        {
            return ExecuteDataTable(sqlString, commandType, 0, null);
        }
        /// <summary>
        /// 執行一個查詢語句，返回一個包含查詢結果的DataTable   
        /// </summary>
        /// <param name="sqlString">要執行的sql語句</param>
        /// <param name="commandType">要執行的查詢語句的類型</param>
        /// <param name="times">超時時間</param>
        /// <returns></returns>
        public DataTable ExecuteDataTable(string sqlString, CommandType commandType, int times)
        {
            return ExecuteDataTable(sqlString, commandType, times, null);
        }
        /// <summary>     
        /// 執行一個查詢語句，返回一個包含查詢結果的DataTable     
        /// </summary>     
        /// <param name="sqlString">要執行的查詢語句</param>     
        /// <param name="times">超時時間</param>
        /// <param name="commandType">執行的SQL語句的類型</param> 
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>  
        /// <returns></returns>  
        public DataTable ExecuteDataTable(string sqlString, CommandType commandType,int times, DbParameter[] parameters)
        {
            using (DbCommand command = CreateDbCommand(sqlString, commandType,times, parameters))
            {
                using (DbDataAdapter adapter = providerFactory.CreateDataAdapter())
                {
                    adapter.SelectCommand = command;
                    DataTable data = new DataTable();
                    adapter.Fill(data);
                    return data;
                }
            }
        } 
        #endregion

        #region 內部私有方法
        /// <summary>
        /// 構建 DbCommand 對象(用來返回一個結果集，而不是一個整數值) 
        /// </summary>
        /// <param name="connection"></param>
        /// <param name="storedProcName"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        private DbCommand CreateDbQueryCommand(DbConnection connection, string storedProcName, IDbDataParameter[] parameters)
        {
            DbCommand command = providerFactory.CreateCommand();
            command.CommandText = storedProcName;
            command.Connection = connection;
            command.CommandType = CommandType.StoredProcedure;
            foreach (DbParameter parameter in parameters)
            {
                if (parameter != null)
                {
                    // 檢查未分配值的輸出參數,將其分配以DBNull.Value.   
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) && (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    command.Parameters.Add(((ICloneable)parameter).Clone());
                }
            }
            return command;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="connection"></param>
        /// <param name="storedProcName"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        private DbCommand CreateDbCommand(DbConnection connection, string storedProcName, IDbDataParameter[] parameters)
        {
            DbCommand command = CreateDbQueryCommand(connection, storedProcName, parameters);
            DbParameter parameter = providerFactory.CreateParameter();
            parameter.ParameterName = "ReturnValue";
            parameter.DbType = DbType.Int32;
            parameter.Size = 4;
            parameter.Direction = ParameterDirection.ReturnValue;
            parameter.SourceColumnNullMapping = false;
            parameter.SourceColumn = string.Empty;
            parameter.SourceVersion = DataRowVersion.Default;
            parameter.Value = null;
            command.Parameters.Add(((ICloneable)parameter).Clone());
            return command;
        }
        /// <summary>
        /// 創建一個DbCommand對象  
        /// </summary>
        /// <param name="cmd">DbCommand對象</param>
        /// <param name="conn">DbConnection數據庫連接</param>
        /// <param name="trans">DbTransaction事務對象</param>
        /// <param name="cmdText">執行的SQL語句</param>
        /// <param name="cmdParms">DbParameter參數數組</param>
        private void CreateDbCommand(DbCommand cmd, DbConnection conn, DbTransaction trans, string cmdText, DbParameter[] cmdParms)
        {
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            if (trans != null)
            {
                cmd.Transaction = trans;
            }
            cmd.CommandType = CommandType.Text;//cmdType;
            if (cmdParms != null)
            {

                foreach (DbParameter parameter in cmdParms)
                {
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
                        (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    cmd.Parameters.Add(((ICloneable)parameter).Clone());
                }
            }
        }
        /// <summary>  
        /// 創建一個DbCommand對象  
        /// </summary>  
        /// <param name="sqlString">要執行的查詢語句</param>     
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>  
        /// <param name="commandType">執行的SQL語句的類型</param>  
        /// <returns></returns>  
        private DbCommand CreateDbCommand(string sqlString, CommandType commandType, int times ,DbParameter[] parameters)
        {
            DbConnection connection = providerFactory.CreateConnection();
            DbCommand command = providerFactory.CreateCommand();
            connection.ConnectionString = ConnectionString;
            command.CommandText = sqlString;
            command.CommandType = commandType;
            command.Connection = connection;
            if (times > 0) { command.CommandTimeout = times; }
            if (!(parameters == null || parameters.Length == 0))
            {
                foreach (DbParameter parameter in parameters)
                {
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
                        (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    command.Parameters.Add(((ICloneable)parameter).Clone());
                }
            }
            return command;
        }
        /// <summary>
        /// 創建一個DbCommand對象  
        /// </summary>
        /// <param name="sqlString">要執行的查詢語句</param>
        /// <param name="times">超時時間</param>
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>
        /// <returns></returns>
        private DbCommand CreateDbCommand(string sqlString, int times, DbParameter[] parameters)
        {
            DbConnection connection = providerFactory.CreateConnection();
            DbCommand command = providerFactory.CreateCommand();
            connection.ConnectionString = ConnectionString;
            command.CommandText = sqlString;
            command.CommandType = CommandType.Text;
            command.Connection = connection;
            command.Transaction = connection.BeginTransaction();

            if (times > 0) { command.CommandTimeout = times; }
            if (!(parameters == null || parameters.Length == 0))
            {
                foreach (DbParameter parameter in parameters)
                {
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
                        (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    command.Parameters.Add(((ICloneable)parameter).Clone());
                }
            }
            return command;
        }
        #endregion

        #region 獲取安全的SQL字符串
        /// <summary>   
        /// 獲取安全的SQL字符串   
        /// </summary>   
        /// <param name="sql"></param>   
        /// <returns></returns>   
        public string GetSafeSQLString(string sql)
        {
            sql = sql.Replace(",", "，");
            sql = sql.Replace(".", "。");
            sql = sql.Replace("(", "（");
            sql = sql.Replace(")", "）");
            sql = sql.Replace(">", "＞");
            sql = sql.Replace("<", "＜");
            sql = sql.Replace("-", "－");
            sql = sql.Replace("+", "＋");
            sql = sql.Replace("=", "＝");
            sql = sql.Replace("?", "？");
            sql = sql.Replace("*", "＊");
            sql = sql.Replace("|", "｜");
            sql = sql.Replace("&", "＆");
            return sql;
        }
        #endregion  

        #region 返回當前連接的數據庫中所有用戶創建的數據庫
        /// <summary> 
        /// 返回當前連接的數據庫中所有用戶創建的數據庫 
        /// </summary> 
        /// <returns></returns> 
        public DataTable GetTables()
        {
            DataTable table = null;
            using (DbConnection con = providerFactory.CreateConnection())
            {
                con.Open();
                table = con.GetSchema("Tables");

            }
            return table;
        }
        #endregion
    }

數據庫中用到的枚舉如下：

#region 數據庫類型枚舉
    /// <summary>  
    /// 數據庫類型枚舉  
    /// </summary>  
    public enum DbProviderType : byte
    {
        /// <summary>
        /// 微軟 SqlServer 數據庫
        /// </summary>
        SqlServer,
        /// <summary>
        /// 開源 MySql數據庫
        /// </summary>
        MySql,
        /// <summary>
        /// 嵌入式輕型數據庫 SQLite
        /// </summary>
        SQLite,
        /// <summary>
        /// 甲骨文 Oracle
        /// </summary>
        Oracle,
        /// <summary>
        /// 開放數據庫互連
        /// </summary>
        ODBC,
        /// <summary>
        /// 面向不同的數據源的低級應用程序接口
        /// </summary>
        OleDb,
        /// <summary>
        /// 跨平台的關系數據庫系統 Firebird
        /// </summary>
        Firebird,
        /// <summary>
        ///加州大學伯克利分校計算機系開發的關系型數據庫 PostgreSql
        /// </summary>
        PostgreSql,
        /// <summary>
        /// IBM出口的一系列關系型數據庫管理系統 DB2
        /// </summary>
        DB2,
        /// <summary>
        /// IBM公司出品的關系數據庫管理系統（RDBMS）家族  Informix
        /// </summary>
        Informix,
        /// <summary>
        /// 微軟推出的一個適用於嵌入到移動應用的精簡數據庫產品 SqlServerCe
        /// </summary>
        SqlServerCe
    } 
    #endregion

數據庫工廠類如下：

#region DbProviderFactory工廠類  
    /// <summary>  
    /// DbProviderFactory工廠類  
    /// </summary>  
    public class ProviderFactory
    {
        private readonly static Dictionary<DbProviderType, string> providerInvariantNames = new Dictionary<DbProviderType, string>();
        private readonly static Dictionary<DbProviderType, DbProviderFactory> providerFactoies = new Dictionary<DbProviderType, DbProviderFactory>(20);

        /// <summary>
        /// 加載已知的數據庫訪問類的程序集
        /// </summary>
        static ProviderFactory()
        {
            providerInvariantNames.Add(DbProviderType.SqlServer, "System.Data.SqlClient");
            providerInvariantNames.Add(DbProviderType.OleDb, "System.Data.OleDb");
            providerInvariantNames.Add(DbProviderType.ODBC, "System.Data.ODBC");
            providerInvariantNames.Add(DbProviderType.Oracle, "Oracle.DataAccess.Client");
            providerInvariantNames.Add(DbProviderType.MySql, "MySql.Data.MySqlClient");
            providerInvariantNames.Add(DbProviderType.SQLite, "System.Data.SQLite");
            providerInvariantNames.Add(DbProviderType.Firebird, "FirebirdSql.Data.Firebird");
            providerInvariantNames.Add(DbProviderType.PostgreSql, "Npgsql");
            providerInvariantNames.Add(DbProviderType.DB2, "IBM.Data.DB2.iSeries");
            providerInvariantNames.Add(DbProviderType.Informix, "IBM.Data.Informix");
            providerInvariantNames.Add(DbProviderType.SqlServerCe, "System.Data.SqlServerCe");
        }
        /// <summary>  
        /// 獲取指定數據庫類型對應的程序集名稱  
        /// </summary>  
        /// <param name="providerType">數據庫類型枚舉</param>  
        /// <returns></returns>  
        public static string GetProviderInvariantName(DbProviderType providerType)
        {
            return providerInvariantNames[providerType];
        }
        /// <summary>  
        /// 獲取指定類型的數據庫對應的DbProviderFactory  
        /// </summary>  
        /// <param name="providerType">數據庫類型枚舉</param>  
        /// <returns></returns>  
        public static DbProviderFactory GetDbProviderFactory(DbProviderType providerType)
        {
            //如果還沒有加載，則加載該DbProviderFactory  
            if (!providerFactoies.ContainsKey(providerType))
            {
                providerFactoies.Add(providerType, ImportDbProviderFactory(providerType));
            }
            return providerFactoies[providerType];
        }
        /// <summary>  
        /// 加載指定數據庫類型的DbProviderFactory  
        /// </summary>  
        /// <param name="providerType">數據庫類型枚舉</param>  
        /// <returns></returns>  
        private static DbProviderFactory ImportDbProviderFactory(DbProviderType providerType)
        {
            string providerName = providerInvariantNames[providerType];
            DbProviderFactory factory = null;
            try
            {
                //從全局程序集中查找  
                factory = DbProviderFactories.GetFactory(providerName);
            }
            catch (ArgumentException e)
            {
                factory = null;
            }
            return factory;
        }
    }  
    #endregion

整個通用類使用很方便，對不同的數據庫都能夠統一操作。因為目前asp.net + MSSQL的開發模式使用很廣，所以我里面默認了連接類型是MSSQL。同時有參構造函數還能夠自動加載不同類型的數據庫。

簡單的調用儲存過程的方法如下：

IDbDataParameter[] iData = { new SqlParameter("@pid", SqlDbType.Int), new SqlParameter("@pageSize", SqlDbType.Int), new SqlParameter("@pageIndex", SqlDbType.Int), new SqlParameter("@SQL", SqlDbType.NVarChar, 10) };
iData[0].Value = 1;
iData[1].Value = 10;
iData[2].Value = 1;
iData[3].Value = "";

DataSet ds = LiFeiLin.DBUtility.DbUtility.GetInstance().RunProcedure("Office_Enterprise_List", iData,"temp");

其他的數據暫未測試。