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>

为了满足这一通用的数据访问操作，我编写了一个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 }

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

欢迎大家进行转载，谢谢大家的光临！

2012-06-14 23:46:54

 

补充说明：

今天我看到很多朋友们提出了不少不同的意见，你们都说得很对，在此非常感谢，本文只是说明这个是.net中算是比较通用的数据库访问辅助类而已，但很多朋友误以为是数据库访问的框架，跟ORM相提并论了，这根本谈不上是什么数据访问框架的。其实ORM也是对ADO.NET进行映射和封装的，自动帮我们生成了相应的CRUD操作，省去了写SQL的时间，确实对我们的开发省了不少工作，本文的帮助类对原生的ADO.NET访问操作起到较为方便和易用的作用，这跟ORM相比，直接用ADO.NET访问数据库操作在性能上应该说更好一些吧，不管怎么样，对于技术，至少要了解和追求深一些吧。

2012-06-15 23:25:59