关于ADO.NET，只须一个连接，一条SQL语句，轻松实现增删改查

1.  该类库根据是否需要事务可分为两个部分，分别由三个构造方法决定
2.         命名空间DBAssistant,类DBAssist
3.         方法ExecNoQueryWithTran() 实现带事务的增删改，返回(int)影响的行数
4.         方法 ExecNoQuery()实现不带事务的增删改，返回(int) 影响的行数
5.         方法ExecScalar() 实现返回首行首列的查询，返回(object)
6.         方法ExecSelect() 返回SqlDataReader
7.         方法GetDataSet() 返回DataSet 
8.         
9. using System;
10. using System.Collections.Generic;
11. using System.Text;
12. using System.Data;
13. using System.Data.SqlClient;
14. using WriteException;
15. namespace DBAssistant
16. {
17.     public class DBAssist
18.     {
19.         /// <summary>
20.         /// 重载的构造方法
21.         /// </summary>
22.         public DBAssist() { }
23.         public DBAssist(string strSql,SqlConnection conn)
24.         {
25.             this.StrSql = strSql;
26.             this.Conn = conn;
27.         }
28.         public DBAssist(string strSql,object obj,SqlConnection conn)
29.         {
30.             this.StrSql = strSql;
31.             this.Obj = obj;
32.             this.Conn = conn;
33.         }
34.         public DBAssist(string strSql, object obj, SqlConnection conn,SqlTransaction sqlTran)
35.         {
36.             this.StrSql = strSql;
37.             this.Obj = obj;
38.             this.Conn = conn;
39.             this.sqlTran = sqlTran;
40.         }
41.         /// <summary>
42.         /// sql语句
43.         /// </summary>
44.         string strSql;
45.         public string StrSql
46.         {
47.             get { return strSql; }
48.             set { strSql = value; }
49.         }
50.         /// <summary>
51.         /// 要操作的对象，需要对数据库操作的数据存于其中
52.         /// </summary>
53.         object obj;
54.         public object Obj
55.         {
56.             get { return obj; }
57.             set { obj = value; }
58.         }
59.         /// <summary>
60.         /// 连接
61.         /// </summary>
62.         SqlConnection conn;
63.         public SqlConnection Conn
64.         {
65.             get { return conn; }
66.             set { conn = value; }
67.         }
68.         /// <summary>
69.         /// 事务
70.         /// </summary>
71.         SqlTransaction sqlTran;
72.         public SqlTransaction SqlTran
73.         {
74.             get { return sqlTran; }
75.             set { sqlTran = value; }
76.         }
77.         public object count;
78.         /// <summary>
79.         /// 带事务增删改方法
80.         /// </summary>
81.         /// <returns>int</returns>
82.         public int ExecNoQueryWithTran() 
83.         {
84.             int num = 0;
85.             try
86.             {
87.                 using (SqlCommand cmd = new SqlCommand(strSql, conn))
88.                 {
89.                     cmd.Transaction = sqlTran;
90.                     num = cmd.ExecuteNonQuery();
91.                     //SqlTran.Commit();
92.                 }
93.             }
94.             catch (Exception ex)
95.             {
96.                 WriException.Write(ex);
97.                 //SqlTran.Rollback();
98.             }
99.                 return num;
100.         }
101.         /// <summary>
102.         /// 不带事务的增删改方法
103.         /// </summary>
104.         /// <returns>int</returns>
105.         public int ExecNoQuery()
106.         {
107.             int num = 0;
108.             try
109.             {
110.                 using (SqlCommand cmd = new SqlCommand(strSql, conn))
111.                 {
112.                     num = cmd.ExecuteNonQuery();
113.                 }
114.             }
115.             catch (Exception ex)
116.             {
117.                 WriException.Write(ex);
118.             }
119.                 return num;
120.         }
121.         /// <summary>
122.         /// 返回 SqlDataReader 的查询方法
123.         /// </summary>
124.         /// <returns>SqlDataReader</returns>
125.         public SqlDataReader ExecSelect() 
126.         {
127.             SqlDataReader dr = null;
128.             try
129.             {
130.                 SqlCommand cmd = new SqlCommand(strSql, conn);
131.                 dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
132.                 return dr;
133.             }
134.             catch (Exception ex)
135.             {
136.                 WriException.Write(ex);
137.             }
138.             return null;
139.         }
140.         /// <summary>
141.         /// 调用ExecuteScalar()方法，返回 object 的查询方法
142.         /// </summary>
143.         /// <returns>Object</returns>
144.         public object ExecScalar() 
145.         {
146.             count=null;
147.             try
148.             {
149.                 using (SqlCommand cmd = new SqlCommand(strSql, conn))
150.                 {
151.                     count = cmd.ExecuteScalar();
152.                 }
153.             }
154.             catch (Exception ex)
155.             {
156.                 WriException.Write(ex);
157.             }
158.             return count;
159.         }
160.         DataSet ds;
161.         /// <summary>
162.         /// 返回DataSet的查询方法
163.         /// </summary>
164.         /// <returns>DataSet</returns>
165.         public DataSet GetDataSet() 
166.         {
167.             ds = null;
168.             using (SqlDataAdapter sda = new SqlDataAdapter(strSql, conn))
169.             {
170.                 using (ds = new DataSet())
171.                 {
172.                     sda.Fill(ds);
173.                 }
174.             }
175.             return ds;
176.         }
177.         
178.     }
179. }