1 /// <summary>
2 /// 数据库的通用访问代码
3 /// 此类为抽象类，不允许实例化，在应用时直接调用即可
4 /// </summary>SqlDataSource
5 public abstract class SqlHelper
6 {
7 //获取数据库连接字符串，其属于静态变量且只读，项目中所有文档可以直接使用，但不能修改
8 public static readonly string ConnectionString = ConfigurationManager.ConnectionStrings["mylifeConnectionString"].ConnectionString;
9
10 //public static readonly string ConnectionStringInventoryDistributedTransaction = ConfigurationManager.ConnectionStrings["SQLConnString2"].ConnectionString;
11 //public static readonly string ConnectionStringOrderDistributedTransaction = ConfigurationManager.ConnectionStrings["SQLConnString3"].ConnectionString;
12 //public static readonly string ConnectionStringProfile = ConfigurationManager.ConnectionStrings["SQLProfileConnString"].ConnectionString;
13
14 // 哈希表用来存储缓存的参数信息，哈希表可以存储任意类型的参数。
15 private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());
16 private static SqlParameter[] parms = null;
17
18 /******************************执行带有多条SQL语句的事务的方法**************************************/
19 public static int ExecuteNonQuery(string connectionString,bool IsTrans, CommandType cmdType, string [] cmdText, ArrayList pramsList)
20 {
21
22 //SqlCommand cmd = new SqlCommand();
23 int pramsListIndex = 0;
24
25 SqlTransaction objTrans = null;
26 //用于返回数据受影响的行数
27 int val = 0;
28
29 try
30 {
31 using (SqlConnection conn = new SqlConnection(connectionString))
32 {
33 foreach (string str in cmdText)
34 {
35 parms = (SqlParameter[])pramsList[pramsListIndex];
36
37 //判断数据库连接状态
38 if (conn.State != ConnectionState.Open)
39 conn.Open();
40
41
42 SqlCommand cmd = new SqlCommand();
43 //判断
44 if (pramsListIndex == 0)
45 {
46 objTrans = conn.BeginTransaction();
47 }
48
49 //通过PrePareCommand方法将参数逐个加入到SqlCommand的参数集合中
50 PrepareCommand(cmd, conn, objTrans, cmdType, str, parms);
51
52 val = cmd.ExecuteNonQuery();
53
54 //清空SqlCommand中的参数列表
55 cmd.Parameters.Clear();
56 pramsListIndex++;
57 }
58 //事务的提交
59 if (objTrans != null) objTrans.Commit();
60 conn.Close();
61 return val;
62 }
63 }
64 catch (Exception err)
65 {
66 val = -1;
67 //事务的回滚
68 if (objTrans != null) objTrans.Rollback();
69 Console.WriteLine(err);
70 }
71
72 return val;
73 }
74
75
76
77 /// <summary>
78 ///执行一个不需要返回值的SqlCommand命令，通过指定专用的连接字符串。
79 /// 使用参数数组形式提供参数列表
80 /// </summary>
81 /// <remarks>
82 /// 使用示例：
83 /// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
84 /// </remarks>
85 /// <param name="connectionString">一个有效的数据库连接字符串</param>
86 /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
87 /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
88 /// <param name="connectionString"></param>
89 /// <param name="cmdType"></param>
90 /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
91 public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
92 {
93
94 SqlCommand cmd = new SqlCommand();
95
96 using (SqlConnection conn = new SqlConnection(connectionString))
97 {
98 //通过PrePareCommand方法将参数逐个加入到SqlCommand的参数集合中
99 PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
100 int val = cmd.ExecuteNonQuery();
101
102 //清空SqlCommand中的参数列表
103 cmd.Parameters.Clear();
104 conn.Close();
105 return val;
106 }
107 }
108
109
110 /// <summary>
111 /// 测试调用存储过程
112 /// </summary>
113 /// <param name="connectionString"></param>
114 /// <param name="cmdType"></param>
115 /// <param name="cmdText"></param>
116 /// <param name="tableName"></param>
117 /// <param name="commandParameters"></param>
118 /// <returns></returns>
119 public static DataSet ExecuteDataSet(string connectionString, CommandType cmdType, string cmdText, string tableName,params SqlParameter[] commandParameters)
120 {
121 DataSet ds = new DataSet();
122 using (SqlConnection conn = new SqlConnection(connectionString))
123 {
124 conn.Open();
125 SqlCommand cmd = new SqlCommand( );
126 using (SqlDataAdapter da = new SqlDataAdapter())
127 {
128 PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
129 da.SelectCommand = cmd;
130 da.Fill(ds, tableName);
131 cmd.Parameters.Clear();
132 conn.Close();
133 }
134 }
135 return ds ;
136 }
137
138
139 /// <summary>
140 ///执行一条不返回结果的SqlCommand，通过一个已经存在的数据库连接
141 /// 使用参数数组提供参数
142 /// </summary>
143 /// <remarks>
144 /// 使用示例：
145 /// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
146 /// </remarks>
147 /// <param name="connection">一个现有的数据库连接</param>
148 /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
149 /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
150 /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
151 /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
152 public static int ExecuteNonQuery(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
153 {
154
155 SqlCommand cmd = new SqlCommand();
156
157 PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
158 int val = cmd.ExecuteNonQuery();
159 cmd.Parameters.Clear();
160 connection.Close();
161 return val;
162 }
163
164 /// <summary>
165 /// 执行一条不返回结果的SqlCommand，通过一个已经存在的数据库事物处理
166 /// 使用参数数组提供参数
167 /// </summary>
168 /// <remarks>
169 /// 使用示例：
170 /// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
171 /// </remarks>
172 /// <param name="trans">一个存在的 sql 事物处理</param>
173 /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
174 /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
175 /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
176 /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
177 public static int ExecuteNonQuery(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
178 {
179 SqlCommand cmd = new SqlCommand();
180 PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);
181 int val = cmd.ExecuteNonQuery();
182 cmd.Parameters.Clear();
183 trans.Connection.Close();
184 return val;
185 }
186
187 /// <summary>
188 /// 执行一条返回结果集的SqlCommand命令，通过专用的连接字符串。
189 /// 使用参数数组提供参数
190 /// </summary>
191 /// <remarks>
192 /// 使用示例：
193 /// SqlDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
194 /// </remarks>
195 /// <param name="connectionString">一个有效的数据库连接字符串</param>
196 /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
197 /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
198 /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
199 /// <returns>返回一个包含结果的SqlDataReader</returns>
200 public static SqlDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
201 {
202 SqlCommand cmd = new SqlCommand();
203 SqlConnection conn = new SqlConnection(connectionString);
204
205 // 在这里使用try/catch处理是因为如果方法出现异常，则SqlDataReader就不存在，
206 //CommandBehavior.CloseConnection的语句就不会执行，触发的异常由catch捕获。
207 //关闭数据库连接，并通过throw再次引发捕捉到的异常。
208 try
209 {
210 PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
211 SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
212 cmd.Parameters.Clear();
213 return rdr;
214 }
215 catch
216 {
217 conn.Close();
218
219 throw;
220 }
221 }
222
223 /// <summary>
224 /// 查询用于不带参数的select语句
225 /// </summary>
226 /// <param name="connectionString">连接字符串</param>
227 /// <param name="cmdType">查询语句的类型</param>
228 /// <param name="cmdText">查询的select语句</param>
229 /// <returns></returns>
230 public static SqlDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText)
231 {
232 SqlCommand cmd = new SqlCommand();
233 SqlConnection conn = new SqlConnection(connectionString);
234
235 // 在这里使用try/catch处理是因为如果方法出现异常，则SqlDataReader就不存在，
236 //CommandBehavior.CloseConnection的语句就不会执行，触发的异常由catch捕获。
237 //关闭数据库连接，并通过throw再次引发捕捉到的异常。
238 try
239 {
240 PrepareCommand(cmd, conn, null, cmdType, cmdText);
241 SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
242 cmd.Parameters.Clear();
243 return rdr;
244 }
245 catch
246 {
247 conn.Close();
248 throw;
249 }
250 }
251
252 /// <summary>
253 /// 执行一条返回第一条记录第一列的SqlCommand命令，通过专用的连接字符串。
254 /// 使用参数数组提供参数
255 /// </summary>
256 /// <remarks>
257 /// 使用示例：
258 /// Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
259 /// </remarks>
260 /// <param name="connectionString">一个有效的数据库连接字符串</param>
261 /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
262 /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
263 /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
264 /// <returns>返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型</returns>
265 public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
266 {
267 SqlCommand cmd = new SqlCommand();
268
269 using (SqlConnection connection = new SqlConnection(connectionString))
270 {
271 PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
272 object val = cmd.ExecuteScalar();
273 cmd.Parameters.Clear();
274 connection.Close();
275 return val;
276 }
277 }
278
279 /// <summary>
280 /// 执行一条返回第一条记录第一列的SqlCommand命令，通过已经存在的数据库连接。
281 /// 使用参数数组提供参数
282 /// </summary>
283 /// <remarks>
284 /// 使用示例：
285 /// Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
286 /// </remarks>
287 /// <param name="connection">一个已经存在的数据库连接</param>
288 /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
289 /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
290 /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
291 /// <returns>返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型</returns>
292 public static object ExecuteScalar(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
293 {
294
295 var cmd = new SqlCommand();
296
297 PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
298 object val = cmd.ExecuteScalar();
299 cmd.Parameters.Clear();
300 connection.Close();
301 return val;
302 }
303
304
305
306 /// <summary>
307 /// 缓存参数数组
308 /// </summary>
309 /// <param name="cacheKey">参数缓存的键值</param>
310 /// <param name="commandParameters">被缓存的参数列表</param>
311 public static void CacheParameters(string cacheKey, params SqlParameter[] commandParameters)
312 {
313 parmCache[cacheKey] = commandParameters;
314 }
315
316 /// <summary>
317 /// 获取被缓存的参数
318 /// </summary>
319 /// <param name="cacheKey">用于查找参数的KEY值</param>
320 /// <returns>返回缓存的参数数组</returns>
321 public static SqlParameter[] GetCachedParameters(string cacheKey)
322 {
323 SqlParameter[] cachedParms = (SqlParameter[])parmCache[cacheKey];
324
325 if (cachedParms == null)
326 return null;
327
328 //新建一个参数的克隆列表
329 SqlParameter[] clonedParms = new SqlParameter[cachedParms.Length];
330
331 //通过循环为克隆参数列表赋值
332 for (int i = 0, j = cachedParms.Length; i < j; i++)
333 //使用clone方法复制参数列表中的参数
334 clonedParms[i] = (SqlParameter)((ICloneable)cachedParms[i]).Clone();
335
336 return clonedParms;
337 }
338
339 /// <summary>
340 /// 为执行命令准备参数
341 /// </summary>
342 /// <param name="cmd">SqlCommand 命令</param>
343 /// <param name="conn">已经存在的数据库连接</param>
344 /// <param name="trans">数据库事物处理</param>
345 /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
346 /// <param name="cmdText">Command text，T-SQL语句 例如 Select * from Products</param>
347 /// <param name="cmdParms">返回带参数的命令</param>
348 private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
349 {
350
351 //判断数据库连接状态
352 if (conn.State != ConnectionState.Open)
353 conn.Open();
354
355 cmd.Connection = conn;
356 cmd.CommandText = cmdText;
357
358 //判断是否需要事物处理
359 if (trans != null)
360 cmd.Transaction = trans;
361
362 cmd.CommandType = cmdType;
363
364 if (cmdParms != null)
365 {
366 foreach (SqlParameter parm in cmdParms)
367 cmd.Parameters.Add(parm);
368 }
369 }
370
371 /// <summary>
372 /// 和上面的方法比就是少了个查询的参数
373 /// </summary>
374 /// <param name="cmd">SqlCommand命令</param>
375 /// <param name="conn">已经存在的数据库的连接</param>
376 /// <param name="trans">数据库事物处理</param>
377 /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
378 /// <param name="cmdText">Command text，T-SQL语句 例如 Select * from Products</param>
379 private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText)
380 {
381
382 //判断数据库连接状态
383 if (conn.State != ConnectionState.Open)
384 conn.Open();
385
386 cmd.Connection = conn;
387 cmd.CommandText = cmdText;
388
389 //判断是否需要事物处理
390 if (trans != null)
391 cmd.Transaction = trans;
392
393 cmd.CommandType = cmdType;
394 }
395
396 }
