SqlHelper

  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     }
posted @ 2019-10-17 21:05 苍云者阅读(51) 评论(0) 收藏举报
苍云者

SqlHelper

公告
