c# 數據庫通用類DbUtility

DbProviderType數據庫類型枚舉

/// <summary>   
    /// 數據庫類型枚舉   
    /// </summary>   
    public enum DbProviderType : byte  
    {  
        SqlServer,  
        MySql,  
        SQLite,  
        Oracle,  
        ODBC,  
        OleDb,  
        Firebird,  
        PostgreSql,  
        DB2,  
        Informix,  
        SqlServerCe  
    }  

DbProviderFactory工廠類   

 

/// <summary>   
    /// DbProviderFactory工廠類   
    /// </summary>   
    public class ProviderFactory  
    {  
        private static Dictionary<DbProviderType, string> providerInvariantNames = new Dictionary<DbProviderType, string>();  
        private static Dictionary<DbProviderType, DbProviderFactory> providerFactoies = new Dictionary<DbProviderType, DbProviderFactory>(20);  
        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;  
        }  
    }  

DbUtility

 public sealed class DbUtility  
    {  
        public string ConnectionString { get; set; }  
        private DbProviderFactory providerFactory;  
        /// <summary>   
        /// 構造函數   
        /// </summary>   
        /// <param name="connectionString">數據庫連接字符串</param>   
        /// <param name="providerType">數據庫類型枚舉，參見<paramref name="providerType"/></param>   
        public 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>      
        /// 對數據庫執行增刪改操作，返回受影響的行數。      
        /// </summary>      
        /// <param name="sql">要執行的增刪改的SQL語句</param>      
        /// <param name="parameters">執行增刪改語句所需要的參數</param>   
        /// <returns></returns>     
        public int ExecuteNonQuery(string sql, IList<DbParameter> parameters)  
        {  
            return ExecuteNonQuery(sql, parameters, CommandType.Text);  
        }  
        /// <summary>      
        /// 對數據庫執行增刪改操作，返回受影響的行數。      
        /// </summary>      
        /// <param name="sql">要執行的增刪改的SQL語句</param>      
        /// <param name="parameters">執行增刪改語句所需要的參數</param>   
        /// <param name="commandType">執行的SQL語句的類型</param>   
        /// <returns></returns>   
        public int ExecuteNonQuery(string sql, IList<DbParameter> parameters, CommandType commandType)  
        {  
            using (DbCommand command = CreateDbCommand(sql, parameters, commandType))  
            {  
                command.Connection.Open();  
                int affectedRows = command.ExecuteNonQuery();  
                command.Connection.Close();  
                return affectedRows;  
            }  
        }  
  
        /// <summary>      
        /// 執行一個查詢語句，返回一個關聯的DataReader實例      
        /// </summary>      
        /// <param name="sql">要執行的查詢語句</param>      
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>   
        /// <returns></returns>    
        public DbDataReader ExecuteReader(string sql, IList<DbParameter> parameters)  
        {  
            return ExecuteReader(sql, parameters, CommandType.Text);  
        }  
  
        /// <summary>      
        /// 執行一個查詢語句，返回一個關聯的DataReader實例      
        /// </summary>      
        /// <param name="sql">要執行的查詢語句</param>      
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>   
        /// <param name="commandType">執行的SQL語句的類型</param>   
        /// <returns></returns>    
        public DbDataReader ExecuteReader(string sql, IList<DbParameter> parameters, CommandType commandType)  
        {  
            DbCommand command = CreateDbCommand(sql, parameters, commandType);  
            command.Connection.Open();  
            return command.ExecuteReader(CommandBehavior.CloseConnection);  
        }  
  
        /// <summary>      
        /// 執行一個查詢語句，返回一個包含查詢結果的DataTable      
        /// </summary>      
        /// <param name="sql">要執行的查詢語句</param>      
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>   
        /// <returns></returns>   
        public DataTable ExecuteDataTable(string sql, IList<DbParameter> parameters)  
        {  
            return ExecuteDataTable(sql, parameters, CommandType.Text);  
        }  
        /// <summary>      
        /// 執行一個查詢語句，返回一個包含查詢結果的DataTable      
        /// </summary>      
        /// <param name="sql">要執行的查詢語句</param>      
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>   
        /// <param name="commandType">執行的SQL語句的類型</param>   
        /// <returns></returns>   
        public DataTable ExecuteDataTable(string sql, IList<DbParameter> parameters, CommandType commandType)  
        {  
            using (DbCommand command = CreateDbCommand(sql, parameters, commandType))  
            {  
                using (DbDataAdapter adapter = providerFactory.CreateDataAdapter())  
                {  
                    adapter.SelectCommand = command;  
                    DataTable data = new DataTable();  
                    adapter.Fill(data);  
                    return data;  
                }  
            }  
        }  
  
        /// <summary>      
        /// 執行一個查詢語句，返回查詢結果的第一行第一列      
        /// </summary>      
        /// <param name="sql">要執行的查詢語句</param>      
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>      
        /// <returns></returns>      
        public Object ExecuteScalar(string sql, IList<DbParameter> parameters)  
        {  
            return ExecuteScalar(sql, parameters, CommandType.Text);  
        }  
  
        /// <summary>      
        /// 執行一個查詢語句，返回查詢結果的第一行第一列      
        /// </summary>      
        /// <param name="sql">要執行的查詢語句</param>      
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>      
        /// <param name="commandType">執行的SQL語句的類型</param>   
        /// <returns></returns>      
        public Object ExecuteScalar(string sql, IList<DbParameter> parameters, CommandType commandType)  
        {  
            using (DbCommand command = CreateDbCommand(sql, parameters, commandType))  
            {  
                command.Connection.Open();  
                object result = command.ExecuteScalar();  
                command.Connection.Close();  
                return result;  
            }  
        }  
  
        /// <summary>   
        /// 查詢多個實體集合   
        /// </summary>   
        /// <typeparam name="T">返回的實體集合類型</typeparam>   
        /// <param name="sql">要執行的查詢語句</param>      
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>   
        /// <returns></returns>   
        public List<T> QueryForList<T>(string sql, IList<DbParameter> parameters) where T : new()  
        {  
            return QueryForList<T>(sql, parameters, CommandType.Text);  
        }  
  
        /// <summary>   
        ///  查詢多個實體集合   
        /// </summary>   
        /// <typeparam name="T">返回的實體集合類型</typeparam>   
        /// <param name="sql">要執行的查詢語句</param>      
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>      
        /// <param name="commandType">執行的SQL語句的類型</param>   
        /// <returns></returns>   
        public List<T> QueryForList<T>(string sql, IList<DbParameter> parameters, CommandType commandType) where T : new()  
        {  
            DataTable data = ExecuteDataTable(sql, parameters, commandType);  
            return EntityReader.GetEntities<T>(data);  
            //return null;
        }  
        /// <summary>   
        /// 查詢單個實體   
        /// </summary>   
        /// <typeparam name="T">返回的實體集合類型</typeparam>   
        /// <param name="sql">要執行的查詢語句</param>      
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>   
        /// <returns></returns>   
        public T QueryForObject<T>(string sql, IList<DbParameter> parameters) where T : new()  
        {  
            return QueryForObject<T>(sql, parameters, CommandType.Text);  
        }  
  
        /// <summary>   
        /// 查詢單個實體   
        /// </summary>   
        /// <typeparam name="T">返回的實體集合類型</typeparam>   
        /// <param name="sql">要執行的查詢語句</param>      
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>      
        /// <param name="commandType">執行的SQL語句的類型</param>   
        /// <returns></returns>   
        public T QueryForObject<T>(string sql, IList<DbParameter> parameters, CommandType commandType) where T : new()  
        {  
            List <T> list= QueryForList<T>(sql, parameters, commandType);  
            if (list.Count > 0)  
            {  
                return list[0];  
            }  
            else  
            {  
                return default(T);  
            }  
        }  
  
        public DbParameter CreateDbParameter(string name, object value)  
        {  
            return CreateDbParameter(name, ParameterDirection.Input, value);  
        }  
  
        public DbParameter CreateDbParameter(string name, ParameterDirection parameterDirection, object value)  
        {  
            DbParameter parameter = providerFactory.CreateParameter();  
            parameter.ParameterName = name;  
            parameter.Value = value;  
            parameter.Direction = parameterDirection;  
            return parameter;  
        }  
  
        /// <summary>   
        /// 創建一個DbCommand對象   
        /// </summary>   
        /// <param name="sql">要執行的查詢語句</param>      
        /// <param name="parameters">執行SQL查詢語句所需要的參數</param>   
        /// <param name="commandType">執行的SQL語句的類型</param>   
        /// <returns></returns>   
        private DbCommand CreateDbCommand(string sql, IList<DbParameter> parameters, CommandType commandType)  
        {  
            DbConnection connection = providerFactory.CreateConnection();  
            DbCommand command = providerFactory.CreateCommand();  
            connection.ConnectionString = ConnectionString;  
            command.CommandText = sql;  
            command.CommandType = commandType;  
            command.Connection = connection;  
            if (!(parameters == null || parameters.Count == 0))  
            {  
                foreach (DbParameter parameter in parameters)  
                {  
                    command.Parameters.Add(parameter);  
                }  
            }  
            return command;  
        }  
    }