zoukankan      html  css  js  c++  java
  • DbHelper通用数据库访问帮助类

    之前我一直都是在博客园中查看各位高手的博文,确实学到了不少知识,不过比较少写博客,现在就把我自己在项目实施过程中使用到比较好的技术框架写出来,希望能让更多的人了解和学习。

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

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

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

    数据库提供程序配置操作、
    1 <?xml version="1.0" encoding="utf-8" ?>
     2 <!--
     3 // 文 件: DbHelper.config
     4 // 作 者: yangdeyong
     5 // 时 间: 2012年4月10日 10:22:23
     6 // 摘 要: 结合DbHelper帮助类,对各种数据库提供程序的配置文件,可支持Odbc、OleDb、OracleClient、SqlClient、SqlServerCe等多种数据库提供程序
     7 -->
     8 <configuration>
     9   <appSettings>
    10     <!--一般有如下一些配置名称 要先安装好相应的数据库提供程序
    11     System.Data.Odbc
    12     System.Data.OleDb
    13     System.Data.OracleClient
    14     System.Data.SqlClient
    15     System.Data.SqlServerCe.3.5
    16     iAnywhere.Data.SQLAnywhere
    17     -->
    18     <!--配置数据库提供程序名称 Key名称不要更改-->
    19     <add key="DbProviderName" value="System.Data.SqlClient"/>
    20 
    21     <!--配置数据库链接字段串值 Key名称不要更改-->
    22     <add key="DbConnectionString" value="Data Source=localhost\SQLEXPRESS;Initial Catalog=ydyTest;Integrated Security=SSPI"/>
    23   </appSettings>
    24 </configuration>
    复制代码
    复制代码
     1 <?xml version="1.0" encoding="utf-8" ?>
     2 <!--
     3 // 文 件: DbHelper.config
     4 // 作 者: yangdeyong
     5 // 时 间: 2012年4月10日 10:22:23
     6 // 摘 要: 结合DbHelper帮助类,对各种数据库提供程序的配置文件,可支持Odbc、OleDb、OracleClient、SqlClient、SqlServerCe等多种数据库提供程序
     7 -->
     8 <configuration>
     9   <appSettings>
    10     <!--一般有如下一些配置名称 要先安装好相应的数据库提供程序
    11     System.Data.Odbc
    12     System.Data.OleDb
    13     System.Data.OracleClient
    14     System.Data.SqlClient
    15     System.Data.SqlServerCe.3.5
    16     iAnywhere.Data.SQLAnywhere
    17     -->
    18     <!--配置数据库提供程序名称 Key名称不要更改-->
    19     <add key="DbProviderName" value="System.Data.SqlClient"/>
    20 
    21     <!--配置数据库链接字段串值 Key名称不要更改-->
    22     <add key="DbConnectionString" value="Data Source=localhost\SQLEXPRESS;Initial Catalog=ydyTest;Integrated Security=SSPI"/>
    23   </appSettings>
    24 </configuration>
    复制代码

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

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

    通用数据库访问帮助类DbHelper.cs
    1 // 文 件: DbHelper.cs
      2 // 作 者: yangdeyong
      3 // 时 间: 2012年4月10日 10:12:45
      4 // 摘 要: .NET通用数据库操作帮助类,可支持Odbc、OleDb、OracleClient、SqlClient、SqlServerCe等多种数据库提供程序操作
      5 
      6 using System;
      7 using System.Collections.Generic;
      8 using System.Data;
      9 using System.Data.Common;
     10 using System.Linq;
     11 using System.Text;
     12 
     13 namespace DbHelper
     14 {
     15     /// <summary>
     16     /// 说 明: .NET通用数据库操作帮助类,可支持Odbc、OleDb、OracleClient、SqlClient、SqlServerCe等多种数据库提供程序操作
     17     /// 作 者: yangdeyong
     18     /// 时 间: 2012-04-10 10:12:45 
     19     /// </summary>
     20     /// <remarks>
     21     /// 作 者: yangdeyong
     22     /// 时 间: 2012-04-10 10:12:45 
     23     /// </remarks>
     24     public sealed class DbHelper
     25     {
     26         #region 字段属性
     27 
     28         #region 静态公有字段
     29         /// <summary>
     30         /// 获取当前数据库配置的提供程序名称值DbProviderName
     31         /// </summary>
     32         public static readonly string DbProviderName = System.Configuration.ConfigurationManager.AppSettings["DbProviderName"];
     33 
     34         /// <summary>
     35         /// 获取当前数据库配置的连接字符串值DbConnectionString
     36         /// </summary>
     37         public static readonly string DbConnectionString = System.Configuration.ConfigurationManager.AppSettings["DbConnectionString"];
     38         #endregion
     39 
     40         #region 私有字段
     41         /// <summary>
     42         /// 当前默认配置的数据库提供程序DbProviderFactory
     43         /// </summary>
     44         private DbProviderFactory _dbFactory = null;
     45 
     46         /// <summary>
     47         /// 当前数据库链接DbConnection对象
     48         /// </summary>
     49         private DbConnection _dbConnection = null;
     50 
     51         /// <summary>
     52         /// 当前的数据库提供程序
     53         /// </summary>
     54         private string _dbProviderName = null;
     55 
     56         /// <summary>
     57         /// 当前的数据库连接字符串
     58         /// </summary>
     59         private string _dbConnectionString = null;
     60         #endregion
     61 
     62         #endregion
     63 
     64         #region 构造函数
     65         /// <summary>
     66         /// 根据配置的数据库提供程序和链接串进行初始化此对象实例
     67         /// </summary>
     68         public DbHelper()
     69             : this(DbHelper.DbConnectionString, DbHelper.DbProviderName)
     70         {
     71         }
     72 
     73         /// <summary>
     74         /// 根据数据库链接串和数据库提供程序名称两个参数进行初始化此对象实例
     75         /// </summary>
     76         /// <param name="connectionString">数据库连接配置字符串</param>
     77         /// <param name="providerName">数据库提供程序的名称</param>
     78         public DbHelper(string connectionString, string providerName)
     79         {
     80             if (!string.IsNullOrEmpty(providerName))
     81             {
     82                 this._dbFactory = DbHelper.CreateDbProviderFactory(providerName);//创建默认配置的数据库提供程序
     83             }
     84             else
     85             {
     86                 throw new ArgumentNullException("providerName", "数据库提供程序名称参数值不能为空,请在配置文件中配置该项值!");
     87             }
     88 
     89             if (!string.IsNullOrEmpty(connectionString))
     90             {
     91                 this._dbConnection = DbHelper.CreateDbConnection(connectionString, providerName);//创建当前数据库链接对象
     92             }
     93             else
     94             {
     95                 throw new ArgumentNullException("connectionString", "数据库链接串参数值不能为空,请在配置文件中配置该项值!");
     96             }
     97 
     98             //保存当前连接字符串和数据库提供程序名称
     99             this._dbConnectionString = connectionString;
    100             this._dbProviderName = providerName;
    101         }
    102         #endregion
    103 
    104         #region 方法函数
    105 
    106         #region 创建DbProviderFactory对象(静态方法)
    107         /// <summary>
    108         /// 根据配置的数据库提供程序的DbProviderName名称来创建一个数据库配置的提供程序DbProviderFactory对象
    109         /// </summary>
    110         public static DbProviderFactory CreateDbProviderFactory()
    111         {
    112             DbProviderFactory dbFactory = DbHelper.CreateDbProviderFactory(DbHelper.DbProviderName);
    113 
    114             return dbFactory;
    115         }
    116 
    117         /// <summary>
    118         /// 根据参数名称创建一个数据库提供程序DbProviderFactory对象
    119         /// </summary>
    120         /// <param name="dbProviderName">数据库提供程序的名称</param>
    121         public static DbProviderFactory CreateDbProviderFactory(string dbProviderName)
    122         {
    123             DbProviderFactory dbFactory = DbProviderFactories.GetFactory(dbProviderName);
    124 
    125             return dbFactory;
    126         }
    127         #endregion
    128 
    129         #region 创建DbConnection对象(静态方法)
    130         /// <summary>
    131         /// 根据配置的数据库提供程序和链接串来创建数据库链接.
    132         /// </summary>
    133         public static DbConnection CreateDbConnection()
    134         {
    135             DbConnection dbConn = DbHelper.CreateDbConnection(DbHelper.DbConnectionString, DbHelper.DbProviderName);
    136 
    137             return dbConn;
    138         }
    139 
    140         /// <summary>
    141         /// 根据数据库连接字符串参数来创建数据库链接.
    142         /// </summary>
    143         /// <param name="connectionString">数据库连接配置字符串</param>
    144         /// <param name="dbProviderName">数据库提供程序的名称</param>
    145         /// <returns></returns>
    146         public static DbConnection CreateDbConnection(string connectionString, string dbProviderName)
    147         {
    148             DbProviderFactory dbFactory = DbHelper.CreateDbProviderFactory(dbProviderName);
    149 
    150             DbConnection dbConn = dbFactory.CreateConnection();
    151             dbConn.ConnectionString = connectionString;
    152 
    153             return dbConn;
    154         }
    155         #endregion
    156 
    157         #region 获取DbCommand对象
    158         /// <summary>
    159         /// 根据存储过程名称来构建当前数据库链接的DbCommand对象
    160         /// </summary>
    161         /// <param name="storedProcedure">存储过程名称</param>
    162         public DbCommand GetStoredProcedureCommond(string storedProcedure)
    163         {
    164             DbCommand dbCmd = this._dbConnection.CreateCommand();
    165 
    166             dbCmd.CommandText = storedProcedure;
    167             dbCmd.CommandType = CommandType.StoredProcedure;
    168 
    169             return dbCmd;
    170         }
    171 
    172         /// <summary>
    173         /// 根据SQL语句来构建当前数据库链接的DbCommand对象
    174         /// </summary>
    175         /// <param name="sqlQuery">SQL查询语句</param>
    176         public DbCommand GetSqlStringCommond(string sqlQuery)
    177         {
    178             DbCommand dbCmd = this._dbConnection.CreateCommand();
    179 
    180             dbCmd.CommandText = sqlQuery;
    181             dbCmd.CommandType = CommandType.Text;
    182 
    183             return dbCmd;
    184         }
    185         #endregion
    186 
    187         #region 添加DbCommand参数
    188         /// <summary>
    189         /// 把参数集合添加到DbCommand对象中
    190         /// </summary>
    191         /// <param name="cmd">数据库命令操作对象</param>
    192         /// <param name="dbParameterCollection">数据库操作集合</param>
    193         public void AddParameterCollection(DbCommand cmd, DbParameterCollection dbParameterCollection)
    194         {
    195             if (cmd != null)
    196             {
    197                 foreach (DbParameter dbParameter in dbParameterCollection)
    198                 {
    199                     cmd.Parameters.Add(dbParameter);
    200                 }
    201             }
    202         }
    203 
    204         /// <summary>
    205         /// 把输出参数添加到DbCommand对象中
    206         /// </summary>
    207         /// <param name="cmd">数据库命令操作对象</param>
    208         /// <param name="parameterName">参数名称</param>
    209         /// <param name="dbType">参数的类型</param>
    210         /// <param name="size">参数的大小</param>
    211         public void AddOutParameter(DbCommand cmd, string parameterName, DbType dbType, int size)
    212         {
    213             if (cmd != null)
    214             {
    215                 DbParameter dbParameter = cmd.CreateParameter();
    216 
    217                 dbParameter.DbType = dbType;
    218                 dbParameter.ParameterName = parameterName;
    219                 dbParameter.Size = size;
    220                 dbParameter.Direction = ParameterDirection.Output;
    221 
    222                 cmd.Parameters.Add(dbParameter);
    223             }
    224         }
    225 
    226         /// <summary>
    227         /// 把输入参数添加到DbCommand对象中
    228         /// </summary>
    229         /// <param name="cmd">数据库命令操作对象</param>
    230         /// <param name="parameterName">参数名称</param>
    231         /// <param name="dbType">参数的类型</param>
    232         /// <param name="value">参数值</param>
    233         public void AddInParameter(DbCommand cmd, string parameterName, DbType dbType, object value)
    234         {
    235             if (cmd != null)
    236             {
    237                 DbParameter dbParameter = cmd.CreateParameter();
    238 
    239                 dbParameter.DbType = dbType;
    240                 dbParameter.ParameterName = parameterName;
    241                 dbParameter.Value = value;
    242                 dbParameter.Direction = ParameterDirection.Input;
    243 
    244                 cmd.Parameters.Add(dbParameter);
    245             }
    246         }
    247 
    248         /// <summary>
    249         /// 把返回参数添加到DbCommand对象中
    250         /// </summary>
    251         /// <param name="cmd">数据库命令操作对象</param>
    252         /// <param name="parameterName">参数名称</param>
    253         /// <param name="dbType">参数的类型</param>
    254         public void AddReturnParameter(DbCommand cmd, string parameterName, DbType dbType)
    255         {
    256             if (cmd != null)
    257             {
    258                 DbParameter dbParameter = cmd.CreateParameter();
    259 
    260                 dbParameter.DbType = dbType;
    261                 dbParameter.ParameterName = parameterName;
    262                 dbParameter.Direction = ParameterDirection.ReturnValue;
    263 
    264                 cmd.Parameters.Add(dbParameter);
    265             }
    266         }
    267 
    268         /// <summary>
    269         /// 根据参数名称从DbCommand对象中获取相应的参数对象
    270         /// </summary>
    271         /// <param name="cmd">数据库命令操作对象</param>
    272         /// <param name="parameterName">参数名称</param>
    273         public DbParameter GetParameter(DbCommand cmd, string parameterName)
    274         {
    275             if (cmd != null && cmd.Parameters.Count > 0)
    276             {
    277                 DbParameter param = cmd.Parameters[parameterName];
    278 
    279                 return param;
    280             }
    281 
    282             return null;
    283         }
    284         #endregion
    285 
    286         #region 执行SQL脚本语句
    287         /// <summary>
    288         /// 执行相应的SQL命令,返回一个DataSet数据集合
    289         /// </summary>
    290         /// <param name="sqlQuery">需要执行的SQL语句</param>
    291         /// <returns>返回一个DataSet数据集合</returns>
    292         public DataSet ExecuteDataSet(string sqlQuery)
    293         {
    294             DataSet ds = new DataSet();
    295 
    296             if (!string.IsNullOrEmpty(sqlQuery))
    297             {
    298                 DbCommand cmd = GetSqlStringCommond(sqlQuery);
    299 
    300                 ds = ExecuteDataSet(cmd);
    301             }
    302 
    303             return ds;
    304         }
    305 
    306         /// <summary>
    307         /// 执行相应的SQL命令,返回一个DataTable数据集
    308         /// </summary>
    309         /// <param name="sqlQuery">需要执行的SQL语句</param>
    310         /// <returns>返回一个DataTable数据集</returns>
    311         public DataTable ExecuteDataTable(string sqlQuery)
    312         {
    313             DataTable dt = new DataTable();
    314 
    315             if (!string.IsNullOrEmpty(sqlQuery))
    316             {
    317                 DbCommand cmd = GetSqlStringCommond(sqlQuery);
    318 
    319                 dt = ExecuteDataTable(cmd);
    320             }
    321 
    322             return dt;
    323         }
    324 
    325         /// <summary>
    326         /// 执行相应的SQL命令,返回一个DbDataReader数据对象,如果没有则返回null值
    327         /// </summary>
    328         /// <param name="sqlQuery">需要执行的SQL命令</param>
    329         /// <returns>返回一个DbDataReader数据对象,如果没有则返回null值</returns>
    330         public DbDataReader ExecuteReader(string sqlQuery)
    331         {
    332             if (!string.IsNullOrEmpty(sqlQuery))
    333             {
    334                 DbCommand cmd = GetSqlStringCommond(sqlQuery);
    335 
    336                 DbDataReader reader = ExecuteReader(cmd);
    337 
    338                 return reader;
    339             }
    340 
    341             return null;
    342         }
    343 
    344         /// <summary>
    345         /// 执行相应的SQL命令,返回影响的数据记录数,如果不成功则返回-1
    346         /// </summary>
    347         /// <param name="sqlQuery">需要执行的SQL命令</param>
    348         /// <returns>返回影响的数据记录数,如果不成功则返回-1</returns>
    349         public int ExecuteNonQuery(string sqlQuery)
    350         {
    351             if (!string.IsNullOrEmpty(sqlQuery))
    352             {
    353                 DbCommand cmd = GetSqlStringCommond(sqlQuery);
    354 
    355                 int retVal = ExecuteNonQuery(cmd);
    356 
    357                 return retVal;
    358             }
    359 
    360             return -1;
    361         }
    362 
    363         /// <summary>
    364         /// 执行相应的SQL命令,返回结果集中的第一行第一列的值,如果不成功则返回null值
    365         /// </summary>
    366         /// <param name="sqlQuery">需要执行的SQL命令</param>
    367         /// <returns>返回结果集中的第一行第一列的值,如果不成功则返回null值</returns>
    368         public object ExecuteScalar(string sqlQuery)
    369         {
    370             if (!string.IsNullOrEmpty(sqlQuery))
    371             {
    372                 DbCommand cmd = GetSqlStringCommond(sqlQuery);
    373 
    374                 object retVal = ExecuteScalar(cmd);
    375 
    376                 return retVal;
    377             }
    378 
    379             return null;
    380         }
    381 
    382         #endregion
    383 
    384         #region 执行DbCommand命令
    385         /// <summary>
    386         /// 执行相应的命令,返回一个DataSet数据集合
    387         /// </summary>
    388         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    389         /// <returns>返回一个DataSet数据集合</returns>
    390         public DataSet ExecuteDataSet(DbCommand cmd)
    391         {
    392             DataSet ds = new DataSet();
    393 
    394             if (cmd != null)
    395             {
    396                 DbDataAdapter dbDataAdapter = this._dbFactory.CreateDataAdapter();
    397                 dbDataAdapter.SelectCommand = cmd;
    398 
    399                 dbDataAdapter.Fill(ds);
    400             }
    401 
    402             return ds;
    403         }
    404 
    405         /// <summary>
    406         /// 执行相应的命令,返回一个DataTable数据集合
    407         /// </summary>
    408         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    409         /// <returns>返回一个DataTable数据集合</returns>
    410         public DataTable ExecuteDataTable(DbCommand cmd)
    411         {
    412             DataTable dataTable = new DataTable();
    413 
    414             if (cmd != null)
    415             {
    416                 DbDataAdapter dbDataAdapter = this._dbFactory.CreateDataAdapter();
    417                 dbDataAdapter.SelectCommand = cmd;
    418 
    419                 dbDataAdapter.Fill(dataTable);
    420             }
    421 
    422             return dataTable;
    423         }
    424 
    425         /// <summary>
    426         /// 执行相应的命令,返回一个DbDataReader数据对象,如果没有则返回null值
    427         /// </summary>
    428         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    429         /// <returns>返回一个DbDataReader数据对象,如果没有则返回null值</returns>
    430         public DbDataReader ExecuteReader(DbCommand cmd)
    431         {
    432             if (cmd != null && cmd.Connection != null)
    433             {
    434                 if (cmd.Connection.State != ConnectionState.Open)
    435                 {
    436                     cmd.Connection.Open();
    437                 }
    438 
    439                 DbDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);//当reader读取结束时自动关闭数据库链接
    440 
    441                 return reader;
    442             }
    443 
    444             return null;
    445         }
    446 
    447         /// <summary>
    448         /// 执行相应的命令,返回影响的数据记录数,如果不成功则返回-1
    449         /// </summary>
    450         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    451         /// <returns>返回影响的数据记录数,如果不成功则返回-1</returns>
    452         public int ExecuteNonQuery(DbCommand cmd)
    453         {
    454             if (cmd != null && cmd.Connection != null)
    455             {
    456                 if (cmd.Connection.State != ConnectionState.Open)
    457                 {
    458                     cmd.Connection.Open();
    459                 }
    460 
    461                 int retVal = cmd.ExecuteNonQuery();
    462 
    463                 cmd.Connection.Close();
    464 
    465                 return retVal;
    466             }
    467 
    468             return -1;
    469         }
    470 
    471         /// <summary>
    472         /// 执行相应的命令,返回结果集中的第一行第一列的值,如果不成功则返回null值
    473         /// </summary>
    474         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    475         /// <returns>返回结果集中的第一行第一列的值,如果不成功则返回null值</returns>
    476         public object ExecuteScalar(DbCommand cmd)
    477         {
    478             if (cmd != null && cmd.Connection != null)
    479             {
    480                 if (cmd.Connection.State != ConnectionState.Open)
    481                 {
    482                     cmd.Connection.Open();
    483                 }
    484 
    485                 object retVal = cmd.ExecuteScalar();
    486 
    487                 cmd.Connection.Close();
    488 
    489                 return retVal;
    490             }
    491 
    492             return null;
    493         }
    494         #endregion
    495 
    496         #region 执行DbTransaction事务
    497         /// <summary>
    498         /// 以事务的方式执行相应的命令,返回一个DataSet数据集合
    499         /// </summary>
    500         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    501         /// <param name="trans">数据库事务对象</param>
    502         /// <returns>返回一个DataSet数据集合</returns>
    503         public DataSet ExecuteDataSet(DbCommand cmd, Trans trans)
    504         {
    505             DataSet ds = new DataSet();
    506 
    507             if (cmd != null)
    508             {
    509                 cmd.Connection = trans.Connection;
    510                 cmd.Transaction = trans.Transaction;
    511 
    512                 DbDataAdapter dbDataAdapter = this._dbFactory.CreateDataAdapter();
    513                 dbDataAdapter.SelectCommand = cmd;
    514 
    515                 dbDataAdapter.Fill(ds);
    516             }
    517 
    518             return ds;
    519         }
    520 
    521         /// <summary>
    522         /// 以事务的方式执行相应的命令,返回一个DataTable数据集合
    523         /// </summary>
    524         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    525         /// <param name="trans">数据库事务对象</param>
    526         /// <returns>返回一个DataTable数据集合</returns>
    527         public DataTable ExecuteDataTable(DbCommand cmd, Trans trans)
    528         {
    529             DataTable dataTable = new DataTable();
    530 
    531             if (cmd != null)
    532             {
    533                 cmd.Connection = trans.Connection;
    534                 cmd.Transaction = trans.Transaction;
    535 
    536                 DbDataAdapter dbDataAdapter = this._dbFactory.CreateDataAdapter();
    537                 dbDataAdapter.SelectCommand = cmd;
    538 
    539                 dbDataAdapter.Fill(dataTable);
    540             }
    541 
    542             return dataTable;
    543         }
    544 
    545         /// <summary>
    546         /// 以事务的方式执行相应的命令,返回一个DbDataReader数据对象,如果没有则返回null值
    547         /// </summary>
    548         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    549         /// <param name="trans">数据库事务对象</param>
    550         /// <returns>返回一个DbDataReader数据对象,如果没有则返回null值</returns>
    551         public DbDataReader ExecuteReader(DbCommand cmd, Trans trans)
    552         {
    553             if (cmd != null)
    554             {
    555                 cmd.Connection.Close();
    556 
    557                 cmd.Connection = trans.Connection;
    558                 cmd.Transaction = trans.Transaction;
    559 
    560                 DbDataReader reader = cmd.ExecuteReader();
    561 
    562                 return reader;
    563             }
    564 
    565             return null;
    566         }
    567 
    568         /// <summary>
    569         /// 以事务的方式执行相应的命令,返回影响的数据记录数,如果不成功则返回-1
    570         /// </summary>
    571         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    572         /// <param name="trans">数据库事务对象</param>
    573         /// <returns>返回影响的数据记录数,如果不成功则返回-1</returns>
    574         public int ExecuteNonQuery(DbCommand cmd, Trans trans)
    575         {
    576             if (cmd != null)
    577             {
    578                 cmd.Connection.Close();
    579 
    580                 cmd.Connection = trans.Connection;
    581                 cmd.Transaction = trans.Transaction;
    582 
    583                 int retVal = cmd.ExecuteNonQuery();
    584 
    585                 return retVal;
    586             }
    587 
    588             return -1;
    589         }
    590 
    591         /// <summary>
    592         /// 以事务的方式执行相应的命令,返回结果集中的第一行第一列的值,如果不成功则返回null值
    593         /// </summary>
    594         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    595         /// <param name="trans">数据库事务对象</param>
    596         /// <returns>返回结果集中的第一行第一列的值,如果不成功则返回null值</returns>
    597         public object ExecuteScalar(DbCommand cmd, Trans trans)
    598         {
    599             if (cmd != null)
    600             {
    601                 cmd.Connection.Close();
    602 
    603                 cmd.Connection = trans.Connection;
    604                 cmd.Transaction = trans.Transaction;
    605 
    606                 object retVal = cmd.ExecuteScalar();
    607 
    608                 return retVal;
    609             }
    610 
    611             return null;
    612         }
    613         #endregion
    614 
    615         #endregion
    616     }
    617 
    618     /// <summary>
    619     /// 说 明: 数据库事务操作对象
    620     /// 作 者: yangdeyong
    621     /// 时 间: 2012-04-10 10:19:23 
    622     /// </summary>
    623     /// <remarks>
    624     /// 作 者: yangdeyong
    625     /// 时 间: 2012-04-10 10:12:45 
    626     /// </remarks>
    627     public sealed class Trans : IDisposable
    628     {
    629         #region 字段属性
    630         private DbConnection connection = null;
    631         /// <summary>
    632         /// 获取当前数据库链接对象
    633         /// </summary>
    634         public DbConnection Connection
    635         {
    636             get
    637             {
    638                 return this.connection;
    639             }
    640         }
    641 
    642         private DbTransaction transaction = null;
    643         /// <summary>
    644         /// 获取当前数据库事务对象
    645         /// </summary>
    646         public DbTransaction Transaction
    647         {
    648             get
    649             {
    650                 return this.transaction;
    651             }
    652         }
    653         #endregion
    654 
    655         #region 构造函数
    656         /// <summary>
    657         /// 根据配置的数据库提供程序和连接字符串来创建此事务对象
    658         /// </summary>
    659         public Trans()
    660             : this(DbHelper.DbConnectionString, DbHelper.DbProviderName)
    661         {
    662         }
    663 
    664         /// <summary>
    665         /// 根据数据库连接字符串来创建此事务对象
    666         /// </summary>
    667         /// <param name="connectionString">数据库连接字符串</param>
    668         /// <param name="dbProviderName">数据库提供程序的名称</param>
    669         public Trans(string connectionString, string dbProviderName)
    670         {
    671             if (!string.IsNullOrEmpty(connectionString))
    672             {
    673                 this.connection = DbHelper.CreateDbConnection(connectionString, dbProviderName);
    674                 this.Connection.Open();
    675 
    676                 this.transaction = this.Connection.BeginTransaction();
    677             }
    678             else
    679             {
    680                 throw new ArgumentNullException("connectionString", "数据库链接串参数值不能为空!");
    681             }
    682         }
    683         #endregion
    684 
    685         #region 方法函数
    686         /// <summary>
    687         /// 提交此数据库事务操作
    688         /// </summary>
    689         public void Commit()
    690         {
    691             this.Transaction.Commit();
    692 
    693             this.Close();
    694         }
    695 
    696         /// <summary>
    697         /// 回滚此数据库事务操作
    698         /// </summary>
    699         public void RollBack()
    700         {
    701             this.Transaction.Rollback();
    702 
    703             this.Close();
    704         }
    705 
    706         /// <summary>
    707         /// 关闭此数据库事务链接
    708         /// </summary>
    709         public void Close()
    710         {
    711             if (this.Connection.State != System.Data.ConnectionState.Closed)
    712             {
    713                 this.Connection.Close();
    714             }
    715         }
    716         #endregion
    717 
    718         #region IDisposable 成员
    719         /// <summary>
    720         /// 执行与释放或重置非托管资源相关的应用程序定义的任务。
    721         /// </summary>
    722         public void Dispose()
    723         {
    724             this.Close();
    725         }
    726         #endregion
    727     }
    728 }
    复制代码
      1 // 文 件: DbHelper.cs
      2 // 作 者: yangdeyong
      3 // 时 间: 2012年4月10日 10:12:45
      4 // 摘 要: .NET通用数据库操作帮助类,可支持Odbc、OleDb、OracleClient、SqlClient、SqlServerCe等多种数据库提供程序操作
      5 
      6 using System;
      7 using System.Collections.Generic;
      8 using System.Data;
      9 using System.Data.Common;
     10 using System.Linq;
     11 using System.Text;
     12 
     13 namespace DbHelper
     14 {
     15     /// <summary>
     16     /// 说 明: .NET通用数据库操作帮助类,可支持Odbc、OleDb、OracleClient、SqlClient、SqlServerCe等多种数据库提供程序操作
     17     /// 作 者: yangdeyong
     18     /// 时 间: 2012-04-10 10:12:45 
     19     /// </summary>
     20     /// <remarks>
     21     /// 作 者: yangdeyong
     22     /// 时 间: 2012-04-10 10:12:45 
     23     /// </remarks>
     24     public sealed class DbHelper
     25     {
     26         #region 字段属性
     27 
     28         #region 静态公有字段
     29         /// <summary>
     30         /// 获取当前数据库配置的提供程序名称值DbProviderName
     31         /// </summary>
     32         public static readonly string DbProviderName = System.Configuration.ConfigurationManager.AppSettings["DbProviderName"];
     33 
     34         /// <summary>
     35         /// 获取当前数据库配置的连接字符串值DbConnectionString
     36         /// </summary>
     37         public static readonly string DbConnectionString = System.Configuration.ConfigurationManager.AppSettings["DbConnectionString"];
     38         #endregion
     39 
     40         #region 私有字段
     41         /// <summary>
     42         /// 当前默认配置的数据库提供程序DbProviderFactory
     43         /// </summary>
     44         private DbProviderFactory _dbFactory = null;
     45 
     46         /// <summary>
     47         /// 当前数据库链接DbConnection对象
     48         /// </summary>
     49         private DbConnection _dbConnection = null;
     50 
     51         /// <summary>
     52         /// 当前的数据库提供程序
     53         /// </summary>
     54         private string _dbProviderName = null;
     55 
     56         /// <summary>
     57         /// 当前的数据库连接字符串
     58         /// </summary>
     59         private string _dbConnectionString = null;
     60         #endregion
     61 
     62         #endregion
     63 
     64         #region 构造函数
     65         /// <summary>
     66         /// 根据配置的数据库提供程序和链接串进行初始化此对象实例
     67         /// </summary>
     68         public DbHelper()
     69             : this(DbHelper.DbConnectionString, DbHelper.DbProviderName)
     70         {
     71         }
     72 
     73         /// <summary>
     74         /// 根据数据库链接串和数据库提供程序名称两个参数进行初始化此对象实例
     75         /// </summary>
     76         /// <param name="connectionString">数据库连接配置字符串</param>
     77         /// <param name="providerName">数据库提供程序的名称</param>
     78         public DbHelper(string connectionString, string providerName)
     79         {
     80             if (!string.IsNullOrEmpty(providerName))
     81             {
     82                 this._dbFactory = DbHelper.CreateDbProviderFactory(providerName);//创建默认配置的数据库提供程序
     83             }
     84             else
     85             {
     86                 throw new ArgumentNullException("providerName", "数据库提供程序名称参数值不能为空,请在配置文件中配置该项值!");
     87             }
     88 
     89             if (!string.IsNullOrEmpty(connectionString))
     90             {
     91                 this._dbConnection = DbHelper.CreateDbConnection(connectionString, providerName);//创建当前数据库链接对象
     92             }
     93             else
     94             {
     95                 throw new ArgumentNullException("connectionString", "数据库链接串参数值不能为空,请在配置文件中配置该项值!");
     96             }
     97 
     98             //保存当前连接字符串和数据库提供程序名称
     99             this._dbConnectionString = connectionString;
    100             this._dbProviderName = providerName;
    101         }
    102         #endregion
    103 
    104         #region 方法函数
    105 
    106         #region 创建DbProviderFactory对象(静态方法)
    107         /// <summary>
    108         /// 根据配置的数据库提供程序的DbProviderName名称来创建一个数据库配置的提供程序DbProviderFactory对象
    109         /// </summary>
    110         public static DbProviderFactory CreateDbProviderFactory()
    111         {
    112             DbProviderFactory dbFactory = DbHelper.CreateDbProviderFactory(DbHelper.DbProviderName);
    113 
    114             return dbFactory;
    115         }
    116 
    117         /// <summary>
    118         /// 根据参数名称创建一个数据库提供程序DbProviderFactory对象
    119         /// </summary>
    120         /// <param name="dbProviderName">数据库提供程序的名称</param>
    121         public static DbProviderFactory CreateDbProviderFactory(string dbProviderName)
    122         {
    123             DbProviderFactory dbFactory = DbProviderFactories.GetFactory(dbProviderName);
    124 
    125             return dbFactory;
    126         }
    127         #endregion
    128 
    129         #region 创建DbConnection对象(静态方法)
    130         /// <summary>
    131         /// 根据配置的数据库提供程序和链接串来创建数据库链接.
    132         /// </summary>
    133         public static DbConnection CreateDbConnection()
    134         {
    135             DbConnection dbConn = DbHelper.CreateDbConnection(DbHelper.DbConnectionString, DbHelper.DbProviderName);
    136 
    137             return dbConn;
    138         }
    139 
    140         /// <summary>
    141         /// 根据数据库连接字符串参数来创建数据库链接.
    142         /// </summary>
    143         /// <param name="connectionString">数据库连接配置字符串</param>
    144         /// <param name="dbProviderName">数据库提供程序的名称</param>
    145         /// <returns></returns>
    146         public static DbConnection CreateDbConnection(string connectionString, string dbProviderName)
    147         {
    148             DbProviderFactory dbFactory = DbHelper.CreateDbProviderFactory(dbProviderName);
    149 
    150             DbConnection dbConn = dbFactory.CreateConnection();
    151             dbConn.ConnectionString = connectionString;
    152 
    153             return dbConn;
    154         }
    155         #endregion
    156 
    157         #region 获取DbCommand对象
    158         /// <summary>
    159         /// 根据存储过程名称来构建当前数据库链接的DbCommand对象
    160         /// </summary>
    161         /// <param name="storedProcedure">存储过程名称</param>
    162         public DbCommand GetStoredProcedureCommond(string storedProcedure)
    163         {
    164             DbCommand dbCmd = this._dbConnection.CreateCommand();
    165 
    166             dbCmd.CommandText = storedProcedure;
    167             dbCmd.CommandType = CommandType.StoredProcedure;
    168 
    169             return dbCmd;
    170         }
    171 
    172         /// <summary>
    173         /// 根据SQL语句来构建当前数据库链接的DbCommand对象
    174         /// </summary>
    175         /// <param name="sqlQuery">SQL查询语句</param>
    176         public DbCommand GetSqlStringCommond(string sqlQuery)
    177         {
    178             DbCommand dbCmd = this._dbConnection.CreateCommand();
    179 
    180             dbCmd.CommandText = sqlQuery;
    181             dbCmd.CommandType = CommandType.Text;
    182 
    183             return dbCmd;
    184         }
    185         #endregion
    186 
    187         #region 添加DbCommand参数
    188         /// <summary>
    189         /// 把参数集合添加到DbCommand对象中
    190         /// </summary>
    191         /// <param name="cmd">数据库命令操作对象</param>
    192         /// <param name="dbParameterCollection">数据库操作集合</param>
    193         public void AddParameterCollection(DbCommand cmd, DbParameterCollection dbParameterCollection)
    194         {
    195             if (cmd != null)
    196             {
    197                 foreach (DbParameter dbParameter in dbParameterCollection)
    198                 {
    199                     cmd.Parameters.Add(dbParameter);
    200                 }
    201             }
    202         }
    203 
    204         /// <summary>
    205         /// 把输出参数添加到DbCommand对象中
    206         /// </summary>
    207         /// <param name="cmd">数据库命令操作对象</param>
    208         /// <param name="parameterName">参数名称</param>
    209         /// <param name="dbType">参数的类型</param>
    210         /// <param name="size">参数的大小</param>
    211         public void AddOutParameter(DbCommand cmd, string parameterName, DbType dbType, int size)
    212         {
    213             if (cmd != null)
    214             {
    215                 DbParameter dbParameter = cmd.CreateParameter();
    216 
    217                 dbParameter.DbType = dbType;
    218                 dbParameter.ParameterName = parameterName;
    219                 dbParameter.Size = size;
    220                 dbParameter.Direction = ParameterDirection.Output;
    221 
    222                 cmd.Parameters.Add(dbParameter);
    223             }
    224         }
    225 
    226         /// <summary>
    227         /// 把输入参数添加到DbCommand对象中
    228         /// </summary>
    229         /// <param name="cmd">数据库命令操作对象</param>
    230         /// <param name="parameterName">参数名称</param>
    231         /// <param name="dbType">参数的类型</param>
    232         /// <param name="value">参数值</param>
    233         public void AddInParameter(DbCommand cmd, string parameterName, DbType dbType, object value)
    234         {
    235             if (cmd != null)
    236             {
    237                 DbParameter dbParameter = cmd.CreateParameter();
    238 
    239                 dbParameter.DbType = dbType;
    240                 dbParameter.ParameterName = parameterName;
    241                 dbParameter.Value = value;
    242                 dbParameter.Direction = ParameterDirection.Input;
    243 
    244                 cmd.Parameters.Add(dbParameter);
    245             }
    246         }
    247 
    248         /// <summary>
    249         /// 把返回参数添加到DbCommand对象中
    250         /// </summary>
    251         /// <param name="cmd">数据库命令操作对象</param>
    252         /// <param name="parameterName">参数名称</param>
    253         /// <param name="dbType">参数的类型</param>
    254         public void AddReturnParameter(DbCommand cmd, string parameterName, DbType dbType)
    255         {
    256             if (cmd != null)
    257             {
    258                 DbParameter dbParameter = cmd.CreateParameter();
    259 
    260                 dbParameter.DbType = dbType;
    261                 dbParameter.ParameterName = parameterName;
    262                 dbParameter.Direction = ParameterDirection.ReturnValue;
    263 
    264                 cmd.Parameters.Add(dbParameter);
    265             }
    266         }
    267 
    268         /// <summary>
    269         /// 根据参数名称从DbCommand对象中获取相应的参数对象
    270         /// </summary>
    271         /// <param name="cmd">数据库命令操作对象</param>
    272         /// <param name="parameterName">参数名称</param>
    273         public DbParameter GetParameter(DbCommand cmd, string parameterName)
    274         {
    275             if (cmd != null && cmd.Parameters.Count > 0)
    276             {
    277                 DbParameter param = cmd.Parameters[parameterName];
    278 
    279                 return param;
    280             }
    281 
    282             return null;
    283         }
    284         #endregion
    285 
    286         #region 执行SQL脚本语句
    287         /// <summary>
    288         /// 执行相应的SQL命令,返回一个DataSet数据集合
    289         /// </summary>
    290         /// <param name="sqlQuery">需要执行的SQL语句</param>
    291         /// <returns>返回一个DataSet数据集合</returns>
    292         public DataSet ExecuteDataSet(string sqlQuery)
    293         {
    294             DataSet ds = new DataSet();
    295 
    296             if (!string.IsNullOrEmpty(sqlQuery))
    297             {
    298                 DbCommand cmd = GetSqlStringCommond(sqlQuery);
    299 
    300                 ds = ExecuteDataSet(cmd);
    301             }
    302 
    303             return ds;
    304         }
    305 
    306         /// <summary>
    307         /// 执行相应的SQL命令,返回一个DataTable数据集
    308         /// </summary>
    309         /// <param name="sqlQuery">需要执行的SQL语句</param>
    310         /// <returns>返回一个DataTable数据集</returns>
    311         public DataTable ExecuteDataTable(string sqlQuery)
    312         {
    313             DataTable dt = new DataTable();
    314 
    315             if (!string.IsNullOrEmpty(sqlQuery))
    316             {
    317                 DbCommand cmd = GetSqlStringCommond(sqlQuery);
    318 
    319                 dt = ExecuteDataTable(cmd);
    320             }
    321 
    322             return dt;
    323         }
    324 
    325         /// <summary>
    326         /// 执行相应的SQL命令,返回一个DbDataReader数据对象,如果没有则返回null值
    327         /// </summary>
    328         /// <param name="sqlQuery">需要执行的SQL命令</param>
    329         /// <returns>返回一个DbDataReader数据对象,如果没有则返回null值</returns>
    330         public DbDataReader ExecuteReader(string sqlQuery)
    331         {
    332             if (!string.IsNullOrEmpty(sqlQuery))
    333             {
    334                 DbCommand cmd = GetSqlStringCommond(sqlQuery);
    335 
    336                 DbDataReader reader = ExecuteReader(cmd);
    337 
    338                 return reader;
    339             }
    340 
    341             return null;
    342         }
    343 
    344         /// <summary>
    345         /// 执行相应的SQL命令,返回影响的数据记录数,如果不成功则返回-1
    346         /// </summary>
    347         /// <param name="sqlQuery">需要执行的SQL命令</param>
    348         /// <returns>返回影响的数据记录数,如果不成功则返回-1</returns>
    349         public int ExecuteNonQuery(string sqlQuery)
    350         {
    351             if (!string.IsNullOrEmpty(sqlQuery))
    352             {
    353                 DbCommand cmd = GetSqlStringCommond(sqlQuery);
    354 
    355                 int retVal = ExecuteNonQuery(cmd);
    356 
    357                 return retVal;
    358             }
    359 
    360             return -1;
    361         }
    362 
    363         /// <summary>
    364         /// 执行相应的SQL命令,返回结果集中的第一行第一列的值,如果不成功则返回null值
    365         /// </summary>
    366         /// <param name="sqlQuery">需要执行的SQL命令</param>
    367         /// <returns>返回结果集中的第一行第一列的值,如果不成功则返回null值</returns>
    368         public object ExecuteScalar(string sqlQuery)
    369         {
    370             if (!string.IsNullOrEmpty(sqlQuery))
    371             {
    372                 DbCommand cmd = GetSqlStringCommond(sqlQuery);
    373 
    374                 object retVal = ExecuteScalar(cmd);
    375 
    376                 return retVal;
    377             }
    378 
    379             return null;
    380         }
    381 
    382         #endregion
    383 
    384         #region 执行DbCommand命令
    385         /// <summary>
    386         /// 执行相应的命令,返回一个DataSet数据集合
    387         /// </summary>
    388         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    389         /// <returns>返回一个DataSet数据集合</returns>
    390         public DataSet ExecuteDataSet(DbCommand cmd)
    391         {
    392             DataSet ds = new DataSet();
    393 
    394             if (cmd != null)
    395             {
    396                 DbDataAdapter dbDataAdapter = this._dbFactory.CreateDataAdapter();
    397                 dbDataAdapter.SelectCommand = cmd;
    398 
    399                 dbDataAdapter.Fill(ds);
    400             }
    401 
    402             return ds;
    403         }
    404 
    405         /// <summary>
    406         /// 执行相应的命令,返回一个DataTable数据集合
    407         /// </summary>
    408         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    409         /// <returns>返回一个DataTable数据集合</returns>
    410         public DataTable ExecuteDataTable(DbCommand cmd)
    411         {
    412             DataTable dataTable = new DataTable();
    413 
    414             if (cmd != null)
    415             {
    416                 DbDataAdapter dbDataAdapter = this._dbFactory.CreateDataAdapter();
    417                 dbDataAdapter.SelectCommand = cmd;
    418 
    419                 dbDataAdapter.Fill(dataTable);
    420             }
    421 
    422             return dataTable;
    423         }
    424 
    425         /// <summary>
    426         /// 执行相应的命令,返回一个DbDataReader数据对象,如果没有则返回null值
    427         /// </summary>
    428         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    429         /// <returns>返回一个DbDataReader数据对象,如果没有则返回null值</returns>
    430         public DbDataReader ExecuteReader(DbCommand cmd)
    431         {
    432             if (cmd != null && cmd.Connection != null)
    433             {
    434                 if (cmd.Connection.State != ConnectionState.Open)
    435                 {
    436                     cmd.Connection.Open();
    437                 }
    438 
    439                 DbDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);//当reader读取结束时自动关闭数据库链接
    440 
    441                 return reader;
    442             }
    443 
    444             return null;
    445         }
    446 
    447         /// <summary>
    448         /// 执行相应的命令,返回影响的数据记录数,如果不成功则返回-1
    449         /// </summary>
    450         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    451         /// <returns>返回影响的数据记录数,如果不成功则返回-1</returns>
    452         public int ExecuteNonQuery(DbCommand cmd)
    453         {
    454             if (cmd != null && cmd.Connection != null)
    455             {
    456                 if (cmd.Connection.State != ConnectionState.Open)
    457                 {
    458                     cmd.Connection.Open();
    459                 }
    460 
    461                 int retVal = cmd.ExecuteNonQuery();
    462 
    463                 cmd.Connection.Close();
    464 
    465                 return retVal;
    466             }
    467 
    468             return -1;
    469         }
    470 
    471         /// <summary>
    472         /// 执行相应的命令,返回结果集中的第一行第一列的值,如果不成功则返回null值
    473         /// </summary>
    474         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    475         /// <returns>返回结果集中的第一行第一列的值,如果不成功则返回null值</returns>
    476         public object ExecuteScalar(DbCommand cmd)
    477         {
    478             if (cmd != null && cmd.Connection != null)
    479             {
    480                 if (cmd.Connection.State != ConnectionState.Open)
    481                 {
    482                     cmd.Connection.Open();
    483                 }
    484 
    485                 object retVal = cmd.ExecuteScalar();
    486 
    487                 cmd.Connection.Close();
    488 
    489                 return retVal;
    490             }
    491 
    492             return null;
    493         }
    494         #endregion
    495 
    496         #region 执行DbTransaction事务
    497         /// <summary>
    498         /// 以事务的方式执行相应的命令,返回一个DataSet数据集合
    499         /// </summary>
    500         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    501         /// <param name="trans">数据库事务对象</param>
    502         /// <returns>返回一个DataSet数据集合</returns>
    503         public DataSet ExecuteDataSet(DbCommand cmd, Trans trans)
    504         {
    505             DataSet ds = new DataSet();
    506 
    507             if (cmd != null)
    508             {
    509                 cmd.Connection = trans.Connection;
    510                 cmd.Transaction = trans.Transaction;
    511 
    512                 DbDataAdapter dbDataAdapter = this._dbFactory.CreateDataAdapter();
    513                 dbDataAdapter.SelectCommand = cmd;
    514 
    515                 dbDataAdapter.Fill(ds);
    516             }
    517 
    518             return ds;
    519         }
    520 
    521         /// <summary>
    522         /// 以事务的方式执行相应的命令,返回一个DataTable数据集合
    523         /// </summary>
    524         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    525         /// <param name="trans">数据库事务对象</param>
    526         /// <returns>返回一个DataTable数据集合</returns>
    527         public DataTable ExecuteDataTable(DbCommand cmd, Trans trans)
    528         {
    529             DataTable dataTable = new DataTable();
    530 
    531             if (cmd != null)
    532             {
    533                 cmd.Connection = trans.Connection;
    534                 cmd.Transaction = trans.Transaction;
    535 
    536                 DbDataAdapter dbDataAdapter = this._dbFactory.CreateDataAdapter();
    537                 dbDataAdapter.SelectCommand = cmd;
    538 
    539                 dbDataAdapter.Fill(dataTable);
    540             }
    541 
    542             return dataTable;
    543         }
    544 
    545         /// <summary>
    546         /// 以事务的方式执行相应的命令,返回一个DbDataReader数据对象,如果没有则返回null值
    547         /// </summary>
    548         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    549         /// <param name="trans">数据库事务对象</param>
    550         /// <returns>返回一个DbDataReader数据对象,如果没有则返回null值</returns>
    551         public DbDataReader ExecuteReader(DbCommand cmd, Trans trans)
    552         {
    553             if (cmd != null)
    554             {
    555                 cmd.Connection.Close();
    556 
    557                 cmd.Connection = trans.Connection;
    558                 cmd.Transaction = trans.Transaction;
    559 
    560                 DbDataReader reader = cmd.ExecuteReader();
    561 
    562                 return reader;
    563             }
    564 
    565             return null;
    566         }
    567 
    568         /// <summary>
    569         /// 以事务的方式执行相应的命令,返回影响的数据记录数,如果不成功则返回-1
    570         /// </summary>
    571         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    572         /// <param name="trans">数据库事务对象</param>
    573         /// <returns>返回影响的数据记录数,如果不成功则返回-1</returns>
    574         public int ExecuteNonQuery(DbCommand cmd, Trans trans)
    575         {
    576             if (cmd != null)
    577             {
    578                 cmd.Connection.Close();
    579 
    580                 cmd.Connection = trans.Connection;
    581                 cmd.Transaction = trans.Transaction;
    582 
    583                 int retVal = cmd.ExecuteNonQuery();
    584 
    585                 return retVal;
    586             }
    587 
    588             return -1;
    589         }
    590 
    591         /// <summary>
    592         /// 以事务的方式执行相应的命令,返回结果集中的第一行第一列的值,如果不成功则返回null值
    593         /// </summary>
    594         /// <param name="cmd">需要执行的DbCommand命令对象</param>
    595         /// <param name="trans">数据库事务对象</param>
    596         /// <returns>返回结果集中的第一行第一列的值,如果不成功则返回null值</returns>
    597         public object ExecuteScalar(DbCommand cmd, Trans trans)
    598         {
    599             if (cmd != null)
    600             {
    601                 cmd.Connection.Close();
    602 
    603                 cmd.Connection = trans.Connection;
    604                 cmd.Transaction = trans.Transaction;
    605 
    606                 object retVal = cmd.ExecuteScalar();
    607 
    608                 return retVal;
    609             }
    610 
    611             return null;
    612         }
    613         #endregion
    614 
    615         #endregion
    616     }
    617 
    618     /// <summary>
    619     /// 说 明: 数据库事务操作对象
    620     /// 作 者: yangdeyong
    621     /// 时 间: 2012-04-10 10:19:23 
    622     /// </summary>
    623     /// <remarks>
    624     /// 作 者: yangdeyong
    625     /// 时 间: 2012-04-10 10:12:45 
    626     /// </remarks>
    627     public sealed class Trans : IDisposable
    628     {
    629         #region 字段属性
    630         private DbConnection connection = null;
    631         /// <summary>
    632         /// 获取当前数据库链接对象
    633         /// </summary>
    634         public DbConnection Connection
    635         {
    636             get
    637             {
    638                 return this.connection;
    639             }
    640         }
    641 
    642         private DbTransaction transaction = null;
    643         /// <summary>
    644         /// 获取当前数据库事务对象
    645         /// </summary>
    646         public DbTransaction Transaction
    647         {
    648             get
    649             {
    650                 return this.transaction;
    651             }
    652         }
    653         #endregion
    654 
    655         #region 构造函数
    656         /// <summary>
    657         /// 根据配置的数据库提供程序和连接字符串来创建此事务对象
    658         /// </summary>
    659         public Trans()
    660             : this(DbHelper.DbConnectionString, DbHelper.DbProviderName)
    661         {
    662         }
    663 
    664         /// <summary>
    665         /// 根据数据库连接字符串来创建此事务对象
    666         /// </summary>
    667         /// <param name="connectionString">数据库连接字符串</param>
    668         /// <param name="dbProviderName">数据库提供程序的名称</param>
    669         public Trans(string connectionString, string dbProviderName)
    670         {
    671             if (!string.IsNullOrEmpty(connectionString))
    672             {
    673                 this.connection = DbHelper.CreateDbConnection(connectionString, dbProviderName);
    674                 this.Connection.Open();
    675 
    676                 this.transaction = this.Connection.BeginTransaction();
    677             }
    678             else
    679             {
    680                 throw new ArgumentNullException("connectionString", "数据库链接串参数值不能为空!");
    681             }
    682         }
    683         #endregion
    684 
    685         #region 方法函数
    686         /// <summary>
    687         /// 提交此数据库事务操作
    688         /// </summary>
    689         public void Commit()
    690         {
    691             this.Transaction.Commit();
    692 
    693             this.Close();
    694         }
    695 
    696         /// <summary>
    697         /// 回滚此数据库事务操作
    698         /// </summary>
    699         public void RollBack()
    700         {
    701             this.Transaction.Rollback();
    702 
    703             this.Close();
    704         }
    705 
    706         /// <summary>
    707         /// 关闭此数据库事务链接
    708         /// </summary>
    709         public void Close()
    710         {
    711             if (this.Connection.State != System.Data.ConnectionState.Closed)
    712             {
    713                 this.Connection.Close();
    714             }
    715         }
    716         #endregion
    717 
    718         #region IDisposable 成员
    719         /// <summary>
    720         /// 执行与释放或重置非托管资源相关的应用程序定义的任务。
    721         /// </summary>
    722         public void Dispose()
    723         {
    724             this.Close();
    725         }
    726         #endregion
    727     }
    728 }
    复制代码

    在这些代码中,可以满足大多数的数据访问操作,如果需要自己还可以再继续扩展的,也欢迎大家指出其中存在的不足之处,谢谢。 

    欢迎大家进行转载,谢谢大家的光临!

    2012-06-14 23:46:54

     
    分类: 数据库
  • 相关阅读:
    ajax封装
    完美运动框架
    表单上传input=file
    面向对象入门
    浅谈javaScript内存
    关于使用iframe的父子页面进行简单的相互传值
    浅谈原生JavaScript的动画和特效
    rem 原理与简介
    移动 web 适配
    jsonp 简单封装
  • 原文地址:https://www.cnblogs.com/Leo_wl/p/2550211.html
Copyright © 2011-2022 走看看