分享一下DbHelper通用数据库访问帮助类

作者：袖梨 2022-06-29

通常我们在开发使用数据库访问帮助类时，都单独的针对某一种数据进行编写相应的数据访问帮助类，如SQLHelper，OracleHelper，OleDbHelper等，其实这些都帮助类的实现都是继承并实现ADO.NET中的数据库访问基类的，如SQLCommand->DbCommand，SQLConnection->DbConnection等，在未优化数据访问层之前，通常的框架结构如下所示：

其实我们现在可以将SQLServer，Oracle等的数据访问模块进行优化，将其合并为一个通用的DbHelper数据访问类，优化后的访问框架如下：

这样在使用数据访问时就可以直接使用DbHeper帮助类，这跟使用哪种数据库无任何关系，也就是说在更换数据库时，不需要侯任何现有的数据访问逻辑代码，这对我们的系统维护起到了很大的作用，在更换数据库时，只需简单的配置一下所使用的数据库提供程序

数据库提供程序配置操作 
 

 代码如下 复制代码

 
 
  
    
    
    
 
    
    
  
 

为了满足这一通用的数据访问操作，我编写了一个DbHelper.cs类库，欢迎大家下载使用，希望可以帮助大家在数据库访问操作上更加方便、快捷，

具体的通用数据库访问帮助类代码如下所示
通用数据库访问帮助类DbHelper.cs

 代码如下 复制代码
 // 文 件: DbHelper.cs
 // 作 者: yangdeyong
 // 时 间: 2012年4月10日 10:12:45
 // 摘 要: .NET通用数据库操作帮助类,可支持Odbc、OleDb、OracleClient、SqlClient、SqlServerCe等多种数据库提供程序操作
 
 using System;
 using System.Collections.Generic;
 using System.Data;
 using System.Data.Common;
 using System.Linq;
 using System.Text;
 
 namespace DbHelper
 {
     ///
     /// 说 明: .NET通用数据库操作帮助类,可支持Odbc、OleDb、OracleClient、SqlClient、SqlServerCe等多种数据库提供程序操作
     /// 作 者: yangdeyong
     /// 时 间: 2012-04-10 10:12:45
     ///
     ///
     /// 作 者: yangdeyong
     /// 时 间: 2012-04-10 10:12:45
     ///
     public sealed class DbHelper
     {
         #region 字段属性
 
         #region 静态公有字段
         ///
         /// 获取当前数据库配置的提供程序名称值DbProviderName
         ///
         public static readonly string DbProviderName = System.Configuration.ConfigurationManager.AppSettings["DbProviderName"];
 
         ///
         /// 获取当前数据库配置的连接字符串值DbConnectionString
         ///
         public static readonly string DbConnectionString = System.Configuration.ConfigurationManager.AppSettings["DbConnectionString"];
         #endregion
 
         #region 私有字段
         ///
         /// 当前默认配置的数据库提供程序DbProviderFactory
         ///
         private DbProviderFactory _dbFactory = null;
 
         ///
         /// 当前数据库链接DbConnection对象
         ///
         private DbConnection _dbConnection = null;
 
         ///
         /// 当前的数据库提供程序
         ///
         private string _dbProviderName = null;
 
         ///
         /// 当前的数据库连接字符串
         ///
         private string _dbConnectionString = null;
         #endregion
 
         #endregion
 
         #region 构造函数
         ///
         /// 根据配置的数据库提供程序和链接串进行初始化此对象实例
         ///
         public DbHelper()
             : this(DbHelper.DbConnectionString, DbHelper.DbProviderName)
         {
         }
 
         ///
         /// 根据数据库链接串和数据库提供程序名称两个参数进行初始化此对象实例
         ///
         /// 数据库连接配置字符串
         /// 数据库提供程序的名称
         public DbHelper(string connectionString, string providerName)
         {
             if (!string.IsNullOrEmpty(providerName))
             {
                 this._dbFactory = DbHelper.CreateDbProviderFactory(providerName);//创建默认配置的数据库提供程序
             }
             else
             {
                 throw new ArgumentNullException("providerName", "数据库提供程序名称参数值不能为空,请在配置文件中配置该项值!");
             }
 
             if (!string.IsNullOrEmpty(connectionString))
             {
                 this._dbConnection = DbHelper.CreateDbConnection(connectionString, providerName);//创建当前数据库链接对象
             }
             else
             {
                 throw new ArgumentNullException("connectionString", "数据库链接串参数值不能为空,请在配置文件中配置该项值!");
             }
 
             //保存当前连接字符串和数据库提供程序名称
             this._dbConnectionString = connectionString;
             this._dbProviderName = providerName;
         }
         #endregion
 
         #region 方法函数
 
         #region 创建DbProviderFactory对象(静态方法)
         ///
         /// 根据配置的数据库提供程序的DbProviderName名称来创建一个数据库配置的提供程序DbProviderFactory对象
         ///
         public static DbProviderFactory CreateDbProviderFactory()
         {
             DbProviderFactory dbFactory = DbHelper.CreateDbProviderFactory(DbHelper.DbProviderName);
 
             return dbFactory;
         }
 
         ///
         /// 根据参数名称创建一个数据库提供程序DbProviderFactory对象
         ///
         /// 数据库提供程序的名称
         public static DbProviderFactory CreateDbProviderFactory(string dbProviderName)
         {
             DbProviderFactory dbFactory = DbProviderFactories.GetFactory(dbProviderName);
 
             return dbFactory;
         }
         #endregion
 
         #region 创建DbConnection对象(静态方法)
         ///
         /// 根据配置的数据库提供程序和链接串来创建数据库链接.
         ///
         public static DbConnection CreateDbConnection()
         {
             DbConnection dbConn = DbHelper.CreateDbConnection(DbHelper.DbConnectionString, DbHelper.DbProviderName);
 
             return dbConn;
         }
 
         ///
         /// 根据数据库连接字符串参数来创建数据库链接.
         ///
         /// 数据库连接配置字符串
         /// 数据库提供程序的名称
         ///
         public static DbConnection CreateDbConnection(string connectionString, string dbProviderName)
         {
             DbProviderFactory dbFactory = DbHelper.CreateDbProviderFactory(dbProviderName);
 
             DbConnection dbConn = dbFactory.CreateConnection();
             dbConn.ConnectionString = connectionString;
 
             return dbConn;
         }
         #endregion
 
         #region 获取DbCommand对象
         ///
         /// 根据存储过程名称来构建当前数据库链接的DbCommand对象
         ///
         /// 存储过程名称
         public DbCommand GetStoredProcedureCommond(string storedProcedure)
         {
             DbCommand dbCmd = this._dbConnection.CreateCommand();
 
             dbCmd.CommandText = storedProcedure;
             dbCmd.CommandType = CommandType.StoredProcedure;
 
             return dbCmd;
         }
 
         ///
         /// 根据SQL语句来构建当前数据库链接的DbCommand对象
         ///
         /// SQL查询语句
         public DbCommand GetSqlStringCommond(string sqlQuery)
         {
             DbCommand dbCmd = this._dbConnection.CreateCommand();
 
             dbCmd.CommandText = sqlQuery;
             dbCmd.CommandType = CommandType.Text;
 
             return dbCmd;
         }
         #endregion
 
         #region 添加DbCommand参数
         ///
         /// 把参数集合添加到DbCommand对象中
         ///
         /// 数据库命令操作对象
         /// 数据库操作集合
         public void AddParameterCollection(DbCommand cmd, DbParameterCollection dbParameterCollection)
         {
             if (cmd != null)
             {
                 foreach (DbParameter dbParameter in dbParameterCollection)
                 {
                     cmd.Parameters.Add(dbParameter);
                 }
             }
         }
 
         ///
         /// 把输出参数添加到DbCommand对象中
         ///
         /// 数据库命令操作对象
         /// 参数名称
         /// 参数的类型
         /// 参数的大小
         public void AddOutParameter(DbCommand cmd, string parameterName, DbType dbType, int size)
         {
             if (cmd != null)
             {
                 DbParameter dbParameter = cmd.CreateParameter();
 
                 dbParameter.DbType = dbType;
                 dbParameter.ParameterName = parameterName;
                 dbParameter.Size = size;
                 dbParameter.Direction = ParameterDirection.Output;
 
                 cmd.Parameters.Add(dbParameter);
             }
         }
 
         ///
         /// 把输入参数添加到DbCommand对象中
         ///
         /// 数据库命令操作对象
         /// 参数名称
         /// 参数的类型
         /// 参数值
         public void AddInParameter(DbCommand cmd, string parameterName, DbType dbType, object value)
         {
             if (cmd != null)
             {
                 DbParameter dbParameter = cmd.CreateParameter();
 
                 dbParameter.DbType = dbType;
                 dbParameter.ParameterName = parameterName;
                 dbParameter.Value = value;
                 dbParameter.Direction = ParameterDirection.Input;
 
                 cmd.Parameters.Add(dbParameter);
             }
         }
 
         ///
         /// 把返回参数添加到DbCommand对象中
         ///
         /// 数据库命令操作对象
         /// 参数名称
         /// 参数的类型
         public void AddReturnParameter(DbCommand cmd, string parameterName, DbType dbType)
         {
             if (cmd != null)
             {
                 DbParameter dbParameter = cmd.CreateParameter();
 
                 dbParameter.DbType = dbType;
                 dbParameter.ParameterName = parameterName;
                 dbParameter.Direction = ParameterDirection.ReturnValue;
 
                 cmd.Parameters.Add(dbParameter);
             }
         }
 
         ///
         /// 根据参数名称从DbCommand对象中获取相应的参数对象
         ///
         /// 数据库命令操作对象
         /// 参数名称
         public DbParameter GetParameter(DbCommand cmd, string parameterName)
         {
             if (cmd != null && cmd.Parameters.Count > 0)
             {
                 DbParameter param = cmd.Parameters[parameterName];
 
                 return param;
             }
 
             return null;
         }
         #endregion
 
         #region 执行SQL脚本语句
         ///
         /// 执行相应的SQL命令，返回一个DataSet数据集合
         ///
         /// 需要执行的SQL语句
         /// 返回一个DataSet数据集合
         public DataSet ExecuteDataSet(string sqlQuery)
         {
             DataSet ds = new DataSet();
 
             if (!string.IsNullOrEmpty(sqlQuery))
             {
                 DbCommand cmd = GetSqlStringCommond(sqlQuery);
 
                 ds = ExecuteDataSet(cmd);
             }
 
             return ds;
         }
 
         ///
         /// 执行相应的SQL命令，返回一个DataTable数据集
         ///
         /// 需要执行的SQL语句
         /// 返回一个DataTable数据集
         public DataTable ExecuteDataTable(string sqlQuery)
         {
             DataTable dt = new DataTable();
 
             if (!string.IsNullOrEmpty(sqlQuery))
             {
                 DbCommand cmd = GetSqlStringCommond(sqlQuery);
 
                 dt = ExecuteDataTable(cmd);
             }
 
             return dt;
         }
 
         ///
         /// 执行相应的SQL命令，返回一个DbDataReader数据对象，如果没有则返回null值
         ///
         /// 需要执行的SQL命令
         /// 返回一个DbDataReader数据对象，如果没有则返回null值
         public DbDataReader ExecuteReader(string sqlQuery)
         {
             if (!string.IsNullOrEmpty(sqlQuery))
             {
                 DbCommand cmd = GetSqlStringCommond(sqlQuery);
 
                 DbDataReader reader = ExecuteReader(cmd);
 
                 return reader;
             }
 
             return null;
         }
 
         ///
         /// 执行相应的SQL命令，返回影响的数据记录数，如果不成功则返回-1
         ///
         /// 需要执行的SQL命令
         /// 返回影响的数据记录数，如果不成功则返回-1
         public int ExecuteNonQuery(string sqlQuery)
         {
             if (!string.IsNullOrEmpty(sqlQuery))
             {
                 DbCommand cmd = GetSqlStringCommond(sqlQuery);
 
                 int retVal = ExecuteNonQuery(cmd);
 
                 return retVal;
             }
 
             return -1;
         }
 
         ///
         /// 执行相应的SQL命令，返回结果集中的第一行第一列的值，如果不成功则返回null值
         ///
         /// 需要执行的SQL命令
         /// 返回结果集中的第一行第一列的值，如果不成功则返回null值
         public object ExecuteScalar(string sqlQuery)
         {
             if (!string.IsNullOrEmpty(sqlQuery))
             {
                 DbCommand cmd = GetSqlStringCommond(sqlQuery);
 
                 object retVal = ExecuteScalar(cmd);
 
                 return retVal;
             }
 
             return null;
         }
 
         #endregion
 
         #region 执行DbCommand命令
         ///
         /// 执行相应的命令，返回一个DataSet数据集合
         ///
         /// 需要执行的DbCommand命令对象
         /// 返回一个DataSet数据集合
         public DataSet ExecuteDataSet(DbCommand cmd)
         {
             DataSet ds = new DataSet();
 
             if (cmd != null)
             {
                 DbDataAdapter dbDataAdapter = this._dbFactory.CreateDataAdapter();
                 dbDataAdapter.SelectCommand = cmd;
 
                 dbDataAdapter.Fill(ds);
             }
 
             return ds;
         }
 
         ///
         /// 执行相应的命令，返回一个DataTable数据集合
         ///
         /// 需要执行的DbCommand命令对象
         /// 返回一个DataTable数据集合
         public DataTable ExecuteDataTable(DbCommand cmd)
         {
             DataTable dataTable = new DataTable();
 
             if (cmd != null)
             {
                 DbDataAdapter dbDataAdapter = this._dbFactory.CreateDataAdapter();
                 dbDataAdapter.SelectCommand = cmd;
 
                 dbDataAdapter.Fill(dataTable);
             }
 
             return dataTable;
         }
 
         ///
         /// 执行相应的命令，返回一个DbDataReader数据对象，如果没有则返回null值
         ///
         /// 需要执行的DbCommand命令对象
         /// 返回一个DbDataReader数据对象，如果没有则返回null值
         public DbDataReader ExecuteReader(DbCommand cmd)
         {
             if (cmd != null && cmd.Connection != null)
             {
                 if (cmd.Connection.State != ConnectionState.Open)
                 {
                     cmd.Connection.Open();
                 }
 
                 DbDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);//当reader读取结束时自动关闭数据库链接
 
                 return reader;
             }
 
             return null;
         }
 
         ///
         /// 执行相应的命令，返回影响的数据记录数，如果不成功则返回-1
         ///
         /// 需要执行的DbCommand命令对象
         /// 返回影响的数据记录数，如果不成功则返回-1
         public int ExecuteNonQuery(DbCommand cmd)
         {
             if (cmd != null && cmd.Connection != null)
             {
                 if (cmd.Connection.State != ConnectionState.Open)
                 {
                     cmd.Connection.Open();
                 }
 
                 int retVal = cmd.ExecuteNonQuery();
 
                 cmd.Connection.Close();
 
                 return retVal;
             }
 
             return -1;
         }
 
         ///
         /// 执行相应的命令，返回结果集中的第一行第一列的值，如果不成功则返回null值
         ///
         /// 需要执行的DbCommand命令对象
         /// 返回结果集中的第一行第一列的值，如果不成功则返回null值
         public object ExecuteScalar(DbCommand cmd)
         {
             if (cmd != null && cmd.Connection != null)
             {
                 if (cmd.Connection.State != ConnectionState.Open)
                 {
                     cmd.Connection.Open();
                 }
 
                 object retVal = cmd.ExecuteScalar();
 
                 cmd.Connection.Close();
 
                 return retVal;
             }
 
             return null;
         }
         #endregion
 
         #region 执行DbTransaction事务
         ///
         /// 以事务的方式执行相应的命令，返回一个DataSet数据集合
         ///
         /// 需要执行的DbCommand命令对象
         /// 数据库事务对象
         /// 返回一个DataSet数据集合
         public DataSet ExecuteDataSet(DbCommand cmd, Trans trans)
         {
             DataSet ds = new DataSet();
 
             if (cmd != null)
             {
                 cmd.Connection = trans.Connection;
                 cmd.Transaction = trans.Transaction;
 
                 DbDataAdapter dbDataAdapter = this._dbFactory.CreateDataAdapter();
                 dbDataAdapter.SelectCommand = cmd;
 
                 dbDataAdapter.Fill(ds);
             }
 
             return ds;
         }
 
         ///
         /// 以事务的方式执行相应的命令，返回一个DataTable数据集合
         ///
         /// 需要执行的DbCommand命令对象
         /// 数据库事务对象
         /// 返回一个DataTable数据集合
         public DataTable ExecuteDataTable(DbCommand cmd, Trans trans)
         {
             DataTable dataTable = new DataTable();
 
             if (cmd != null)
             {
                 cmd.Connection = trans.Connection;
                 cmd.Transaction = trans.Transaction;
 
                 DbDataAdapter dbDataAdapter = this._dbFactory.CreateDataAdapter();
                 dbDataAdapter.SelectCommand = cmd;
 
                 dbDataAdapter.Fill(dataTable);
             }
 
             return dataTable;
         }
 
         ///
         /// 以事务的方式执行相应的命令，返回一个DbDataReader数据对象，如果没有则返回null值
         ///
         /// 需要执行的DbCommand命令对象
         /// 数据库事务对象
         /// 返回一个DbDataReader数据对象，如果没有则返回null值
         public DbDataReader ExecuteReader(DbCommand cmd, Trans trans)
         {
             if (cmd != null)
             {
                 cmd.Connection.Close();
 
                 cmd.Connection = trans.Connection;
                 cmd.Transaction = trans.Transaction;
 
                 DbDataReader reader = cmd.ExecuteReader();
 
                 return reader;
             }
 
             return null;
         }
 
         ///
         /// 以事务的方式执行相应的命令，返回影响的数据记录数，如果不成功则返回-1
         ///
         /// 需要执行的DbCommand命令对象
         /// 数据库事务对象
         /// 返回影响的数据记录数，如果不成功则返回-1
         public int ExecuteNonQuery(DbCommand cmd, Trans trans)
         {
             if (cmd != null)
             {
                 cmd.Connection.Close();
 
                 cmd.Connection = trans.Connection;
                 cmd.Transaction = trans.Transaction;
 
                 int retVal = cmd.ExecuteNonQuery();
 
                 return retVal;
             }
 
             return -1;
         }
 
         ///
         /// 以事务的方式执行相应的命令，返回结果集中的第一行第一列的值，如果不成功则返回null值
         ///
         /// 需要执行的DbCommand命令对象
         /// 数据库事务对象
         /// 返回结果集中的第一行第一列的值，如果不成功则返回null值
         public object ExecuteScalar(DbCommand cmd, Trans trans)
         {
             if (cmd != null)
             {
                 cmd.Connection.Close();
 
                 cmd.Connection = trans.Connection;
                 cmd.Transaction = trans.Transaction;
 
                 object retVal = cmd.ExecuteScalar();
 
                 return retVal;
             }
 
             return null;
         }
         #endregion
 
         #endregion
     }
 
     ///
     /// 说 明: 数据库事务操作对象
     /// 作 者: yangdeyong
     /// 时 间: 2012-04-10 10:19:23
     ///
     ///
     /// 作 者: yangdeyong
     /// 时 间: 2012-04-10 10:12:45
     ///
     public sealed class Trans : IDisposable
     {
         #region 字段属性
         private DbConnection connection = null;
         ///
         /// 获取当前数据库链接对象
         ///
         public DbConnection Connection
         {
             get
             {
                 return this.connection;
             }
         }
 
         private DbTransaction transaction = null;
         ///
         /// 获取当前数据库事务对象
         ///
         public DbTransaction Transaction
         {
             get
             {
                 return this.transaction;
             }
         }
         #endregion
 
         #region 构造函数
         ///
         /// 根据配置的数据库提供程序和连接字符串来创建此事务对象
         ///
         public Trans()
             : this(DbHelper.DbConnectionString, DbHelper.DbProviderName)
         {
         }
 
         ///
         /// 根据数据库连接字符串来创建此事务对象
         ///
         /// 数据库连接字符串
         /// 数据库提供程序的名称
         public Trans(string connectionString, string dbProviderName)
         {
             if (!string.IsNullOrEmpty(connectionString))
             {
                 this.connection = DbHelper.CreateDbConnection(connectionString, dbProviderName);
                 this.Connection.Open();
 
                 this.transaction = this.Connection.BeginTransaction();
             }
             else
             {
                 throw new ArgumentNullException("connectionString", "数据库链接串参数值不能为空!");
             }
         }
         #endregion
 
         #region 方法函数
         ///
         /// 提交此数据库事务操作
         ///
         public void Commit()
         {
             this.Transaction.Commit();
 
             this.Close();
         }
 
         ///
         /// 回滚此数据库事务操作
         ///
         public void RollBack()
         {
             this.Transaction.Rollback();
 
             this.Close();
         }
 
         ///
         /// 关闭此数据库事务链接
         ///
        

相关文章

精彩推荐

一聚教程网

Copyright © 2010-2022

111cn.net All Rights Reserved