SqlHelper帮助类
作者：互联网
SqlHelper帮助类
1 public class DbHelper
2 {
3 //数据库连接字符串(web.config来配置)，多数据库可使用DbHelperSQLP来实现.
4 public static string connectionString = ConfigurationManager.ConnectionStrings[""].ConnectionString;
5 public DbHelper()
6 {
7
8 }
9
10 public DbHelper(string connString)
11 {
12 connectionString = connString;
13 }
14
15 /// <summary>
16 /// 判断是否存在某表的某个字段
17 /// </summary>
18 /// <param name="tableName">表名称</param>
19 /// <param name="columnName">列名称</param>
20 /// <returns>是否存在</returns>
21 public static bool ColumnExists(string tableName, string columnName)
22 {
23 string sql = "select count(1) from syscolumns where [id]=object_id('" + tableName + "') and [name]='" + columnName + "'";
24 object res = GetSingle(sql);
25 if (res == null)
26 {
27 return false;
28 }
29 return Convert.ToInt32(res) > 0;
30 }
31 public static int GetMaxID(string FieldName, string TableName)
32 {
33 string strsql = "select max(" + FieldName + ")+1 from " + TableName;
34 object obj = GetSingle(strsql);
35 if (obj == null)
36 {
37 return 1;
38 }
39 else
40 {
41 return int.Parse(obj.ToString());
42 }
43 }
44 public static bool Exists(string strSql)
45 {
46 object obj = GetSingle(strSql);
47 int cmdresult;
48 if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
49 {
50 cmdresult = 0;
51 }
52 else
53 {
54 cmdresult = int.Parse(obj.ToString()); //也可能=0
55 }
56 if (cmdresult == 0)
57 {
58 return false;
59 }
60 else
61 {
62 return true;
63 }
64 }
65
66 /// <summary>
67 /// 表是否存在
68 /// </summary>
69 /// <param name="TableName"></param>
70 /// <returns></returns>
71 public static bool TabExists(string TableName)
72 {
73 string strsql = "select count(*) from sysobjects where id = object_id(N'[" + TableName + "]') and OBJECTPROPERTY(id, N'IsUserTable') = 1";
74 //string strsql = "SELECT count(*) FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[" + TableName + "]') AND type in (N'U')";
75 object obj = GetSingle(strsql);
76 int cmdresult;
77 if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
78 {
79 cmdresult = 0;
80 }
81 else
82 {
83 cmdresult = int.Parse(obj.ToString());
84 }
85 if (cmdresult == 0)
86 {
87 return false;
88 }
89 else
90 {
91 return true;
92 }
93 }
94 public static bool Exists(string strSql, params SqlParameter[] cmdParms)
95 {
96 object obj = GetSingle(strSql, cmdParms);
97 int cmdresult;
98 if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
99 {
100 cmdresult = 0;
101 }
102 else
103 {
104 cmdresult = int.Parse(obj.ToString());
105 }
106 if (cmdresult == 0)
107 {
108 return false;
109 }
110 else
111 {
112 return true;
113 }
114 }
115
116
117 /// <summary>
118 /// 执行SQL语句，返回影响的记录数
119 /// </summary>
120 /// <param name="SQLString">SQL语句</param>
121 /// <returns>影响的记录数</returns>
122 public static int ExecuteSql(string SQLString)
123 {
124 using (SqlConnection connection = new SqlConnection(connectionString))
125 {
126 using (SqlCommand cmd = new SqlCommand(SQLString, connection))
127 {
128 try
129 {
130 connection.Open();
131 int rows = cmd.ExecuteNonQuery();
132 return rows;
133 }
134 catch (System.Data.SqlClient.SqlException e)
135 {
136 connection.Close();
137 throw e;
138 }
139 }
140 }
141 }
142
143 public static int ExecuteSqlByTime(string SQLString, int Times)
144 {
145 using (SqlConnection connection = new SqlConnection(connectionString))
146 {
147 using (SqlCommand cmd = new SqlCommand(SQLString, connection))
148 {
149 try
150 {
151 connection.Open();
152 cmd.CommandTimeout = Times;
153 int rows = cmd.ExecuteNonQuery();
154 return rows;
155 }
156 catch (System.Data.SqlClient.SqlException e)
157 {
158 connection.Close();
159 throw e;
160 }
161 }
162 }
163 }
164
165
166 /// <summary>
167 /// 执行Sql和Oracle滴混合事务
168 /// </summary>
169 /// <param name="list">SQL命令行列表</param>
170 /// <param name="oracleCmdSqlList">Oracle命令行列表</param>
171 /// <returns>执行结果 0-由于SQL造成事务失败 -1 由于Oracle造成事务失败 1-整体事务执行成功</returns>
172 //public static int ExecuteSqlTran(List<CommandInfo> list, List<CommandInfo> oracleCmdSqlList)
173 //{
174 // using (SqlConnection conn = new SqlConnection(connectionString))
175 // {
176 // conn.Open();
177 // SqlCommand cmd = new SqlCommand();
178 // cmd.Connection = conn;
179 // SqlTransaction tx = conn.BeginTransaction();
180 // cmd.Transaction = tx;
181 // try
182 // {
183 // foreach (CommandInfo myDE in list)
184 // {
185 // string cmdText = myDE.CommandText;
186 // SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;
187 // PrepareCommand(cmd, conn, tx, cmdText, cmdParms);
188 // if (myDE.EffentNextType == EffentNextType.SolicitationEvent)
189 // {
190 // if (myDE.CommandText.ToLower().IndexOf("count(") == -1)
191 // {
192 // tx.Rollback();
193 // throw new Exception("违背要求" + myDE.CommandText + "必须符合select count(..的格式");
194 // //return 0;
195 // }
196
197 // object obj = cmd.ExecuteScalar();
198 // bool isHave = false;
199 // if (obj == null && obj == DBNull.Value)
200 // {
201 // isHave = false;
202 // }
203 // isHave = Convert.ToInt32(obj) > 0;
204 // if (isHave)
205 // {
206 // //引发事件
207 // myDE.OnSolicitationEvent();
208 // }
209 // }
210 // if (myDE.EffentNextType == EffentNextType.WhenHaveContine || myDE.EffentNextType == EffentNextType.WhenNoHaveContine)
211 // {
212 // if (myDE.CommandText.ToLower().IndexOf("count(") == -1)
213 // {
214 // tx.Rollback();
215 // throw new Exception("SQL:违背要求" + myDE.CommandText + "必须符合select count(..的格式");
216 // //return 0;
217 // }
218
219 // object obj = cmd.ExecuteScalar();
220 // bool isHave = false;
221 // if (obj == null && obj == DBNull.Value)
222 // {
223 // isHave = false;
224 // }
225 // isHave = Convert.ToInt32(obj) > 0;
226
227 // if (myDE.EffentNextType == EffentNextType.WhenHaveContine && !isHave)
228 // {
229 // tx.Rollback();
230 // throw new Exception("SQL:违背要求" + myDE.CommandText + "返回值必须大于0");
231 // //return 0;
232 // }
233 // if (myDE.EffentNextType == EffentNextType.WhenNoHaveContine && isHave)
234 // {
235 // tx.Rollback();
236 // throw new Exception("SQL:违背要求" + myDE.CommandText + "返回值必须等于0");
237 // //return 0;
238 // }
239 // continue;
240 // }
241 // int val = cmd.ExecuteNonQuery();
242 // if (myDE.EffentNextType == EffentNextType.ExcuteEffectRows && val == 0)
243 // {
244 // tx.Rollback();
245 // throw new Exception("SQL:违背要求" + myDE.CommandText + "必须有影响行");
246 // //return 0;
247 // }
248 // cmd.Parameters.Clear();
249 // }
250 // string oraConnectionString = PubConstant.GetConnectionString("ConnectionStringPPC");
251 // bool res = OracleHelper.ExecuteSqlTran(oraConnectionString, oracleCmdSqlList);
252 // if (!res)
253 // {
254 // tx.Rollback();
255 // throw new Exception("Oracle执行失败");
256 // // return -1;
257 // }
258 // tx.Commit();
259 // return 1;
260 // }
261 // catch (System.Data.SqlClient.SqlException e)
262 // {
263 // tx.Rollback();
264 // throw e;
265 // }
266 // catch (Exception e)
267 // {
268 // tx.Rollback();
269 // throw e;
270 // }
271 // }
272 //}
273
274
275 /// <summary>
276 /// 执行多条SQL语句，实现数据库事务。
277 /// </summary>
278 /// <param name="SQLStringList">多条SQL语句</param>
279 public static int ExecuteSqlTran(List<String> SQLStringList)
280 {
281 using (SqlConnection conn = new SqlConnection(connectionString))
282 {
283 conn.Open();
284 SqlCommand cmd = new SqlCommand();
285 cmd.Connection = conn;
286 SqlTransaction tx = conn.BeginTransaction();
287 cmd.Transaction = tx;
288 try
289 {
290 int count = 0;
291 for (int n = 0; n < SQLStringList.Count; n++)
292 {
293 string strsql = SQLStringList[n];
294 if (strsql.Trim().Length > 1)
295 {
296 cmd.CommandText = strsql;
297 count += cmd.ExecuteNonQuery();
298 }
299 }
300 tx.Commit();
301 return count;
302 }
303 catch
304 {
305 tx.Rollback();
306 return 0;
307 }
308 }
309 }
310
311
312 /// <summary>
313 /// 执行带一个存储过程参数的的SQL语句。
314 /// </summary>
315 /// <param name="SQLString">SQL语句</param>
316 /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
317 /// <returns>影响的记录数</returns>
318 public static int ExecuteSql(string SQLString, string content)
319 {
320 using (SqlConnection connection = new SqlConnection(connectionString))
321 {
322 SqlCommand cmd = new SqlCommand(SQLString, connection);
323 System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
324 myParameter.Value = content;
325 cmd.Parameters.Add(myParameter);
326 try
327 {
328 connection.Open();
329 int rows = cmd.ExecuteNonQuery();
330 return rows;
331 }
332 catch (System.Data.SqlClient.SqlException e)
333 {
334 throw e;
335 }
336 finally
337 {
338 cmd.Dispose();
339 connection.Close();
340 }
341 }
342 }
343
344
345 /// <summary>
346 /// 执行带一个存储过程参数的的SQL语句。
347 /// </summary>
348 /// <param name="SQLString">SQL语句</param>
349 /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
350 /// <returns>影响的记录数</returns>
351 public static object ExecuteSqlGet(string SQLString, string content)
352 {
353 using (SqlConnection connection = new SqlConnection(connectionString))
354 {
355 SqlCommand cmd = new SqlCommand(SQLString, connection);
356 System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
357 myParameter.Value = content;
358 cmd.Parameters.Add(myParameter);
359 try
360 {
361 connection.Open();
362 object obj = cmd.ExecuteScalar();
363 if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
364 {
365 return null;
366 }
367 else
368 {
369 return obj;
370 }
371 }
372 catch (System.Data.SqlClient.SqlException e)
373 {
374 throw e;
375 }
376 finally
377 {
378 cmd.Dispose();
379 connection.Close();
380 }
381 }
382 }
383
384
385 /// <summary>
386 /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
387 /// </summary>
388 /// <param name="strSQL">SQL语句</param>
389 /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
390 /// <returns>影响的记录数</returns>
391 public static int ExecuteSqlInsertImg(string strSQL, byte[] fs)
392 {
393 using (SqlConnection connection = new SqlConnection(connectionString))
394 {
395 SqlCommand cmd = new SqlCommand(strSQL, connection);
396 System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@fs", SqlDbType.Image);
397 myParameter.Value = fs;
398 cmd.Parameters.Add(myParameter);
399 try
400 {
401 connection.Open();
402 int rows = cmd.ExecuteNonQuery();
403 return rows;
404 }
405 catch (System.Data.SqlClient.SqlException e)
406 {
407 throw e;
408 }
409 finally
410 {
411 cmd.Dispose();
412 connection.Close();
413 }
414 }
415 }
416
417
418 /// <summary>
419 /// 执行一条计算查询结果语句，返回查询结果（object）。
420 /// </summary>
421 /// <param name="SQLString">计算查询结果语句</param>
422 /// <returns>查询结果（object）</returns>
423 public static object GetSingle(string SQLString)
424 {
425 using (SqlConnection connection = new SqlConnection(connectionString))
426 {
427 using (SqlCommand cmd = new SqlCommand(SQLString, connection))
428 {
429 try
430 {
431 connection.Open();
432 object obj = cmd.ExecuteScalar();
433 if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
434 {
435 return null;
436 }
437 else
438 {
439 return obj;
440 }
441 }
442 catch (System.Data.SqlClient.SqlException e)
443 {
444 connection.Close();
445 throw e;
446 }
447 }
448 }
449 }
450 public static object GetSingle(string SQLString, int Times)
451 {
452 using (SqlConnection connection = new SqlConnection(connectionString))
453 {
454 using (SqlCommand cmd = new SqlCommand(SQLString, connection))
455 {
456 try
457 {
458 connection.Open();
459 cmd.CommandTimeout = Times;
460 object obj = cmd.ExecuteScalar();
461 if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
462 {
463 return null;
464 }
465 else
466 {
467 return obj;
468 }
469 }
470 catch (System.Data.SqlClient.SqlException e)
471 {
472 connection.Close();
473 throw e;
474 }
475 }
476 }
477 }
478
479 /// <summary>
480 /// 执行查询语句，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
481 /// </summary>
482 /// <param name="strSQL">查询语句</param>
483 /// <returns>SqlDataReader</returns>
484 public static SqlDataReader ExecuteReader(string strSQL)
485 {
486 SqlConnection connection = new SqlConnection(connectionString);
487 SqlCommand cmd = new SqlCommand(strSQL, connection);
488 try
489 {
490 connection.Open();
491 SqlDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
492 return myReader;
493 }
494 catch (System.Data.SqlClient.SqlException e)
495 {
496 throw e;
497 }
498
499 }
500
501
502 /// <summary>
503 /// 执行查询语句，返回DataSet
504 /// </summary>
505 /// <param name="SQLString">查询语句</param>
506 /// <returns>DataSet</returns>
507 public static DataSet Query(string SQLString)
508 {
509 using (SqlConnection connection = new SqlConnection(connectionString))
510 {
511 DataSet ds = new DataSet();
512 try
513 {
514 connection.Open();
515 SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
516 command.Fill(ds, "ds");
517 }
518 catch (System.Data.SqlClient.SqlException ex)
519 {
520 throw new Exception(ex.Message);
521 }
522 return ds;
523 }
524 }
525 public static DataSet Query(string SQLString, int Times)
526 {
527 using (SqlConnection connection = new SqlConnection(connectionString))
528 {
529 DataSet ds = new DataSet();
530 try
531 {
532 connection.Open();
533 SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
534 command.SelectCommand.CommandTimeout = Times;
535 command.Fill(ds, "ds");
536 }
537 catch (System.Data.SqlClient.SqlException ex)
538 {
539 throw new Exception(ex.Message);
540 }
541 return ds;
542 }
543 }
544
545 /// <summary>
546 /// 执行SQL语句，返回影响的记录数
547 /// </summary>
548 /// <param name="SQLString">SQL语句</param>
549 /// <returns>影响的记录数</returns>
550 public static int ExecuteSql(string SQLString, params SqlParameter[] cmdParms)
551 {
552 using (SqlConnection connection = new SqlConnection(connectionString))
553 {
554 using (SqlCommand cmd = new SqlCommand())
555 {
556 try
557 {
558 PrepareCommand(cmd, connection, null, SQLString, cmdParms);
559 int rows = cmd.ExecuteNonQuery();
560 cmd.Parameters.Clear();
561 return rows;
562 }
563 catch (System.Data.SqlClient.SqlException e)
564 {
565 throw e;
566 }
567 }
568 }
569 }
570
571 /// <summary>
572 /// 执行多条SQL语句，实现数据库事务。
573 /// </summary>
574 /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
575 public static void ExecuteSqlTran(Hashtable SQLStringList)
576 {
577 using (SqlConnection conn = new SqlConnection(connectionString))
578 {
579 conn.Open();
580 using (SqlTransaction trans = conn.BeginTransaction())
581 {
582 SqlCommand cmd = new SqlCommand();
583 try
584 {
585 //循环
586 foreach (DictionaryEntry myDE in SQLStringList)
587 {
588 string cmdText = myDE.Key.ToString();
589 SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
590 PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
591 int val = cmd.ExecuteNonQuery();
592 cmd.Parameters.Clear();
593 }
594 trans.Commit();
595 }
596 catch
597 {
598 trans.Rollback();
599 throw;
600 }
601 }
602 }
603 }
604
605 /// <summary>
606 /// 执行多条SQL语句，实现数据库事务。
607 /// </summary>
608 /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
609 public static void ExecuteSqlTranWithIndentity(Hashtable SQLStringList)
610 {
611 using (SqlConnection conn = new SqlConnection(connectionString))
612 {
613 conn.Open();
614 using (SqlTransaction trans = conn.BeginTransaction())
615 {
616 SqlCommand cmd = new SqlCommand();
617 try
618 {
619 int indentity = 0;
620 //循环
621 foreach (DictionaryEntry myDE in SQLStringList)
622 {
623 string cmdText = myDE.Key.ToString();
624 SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
625 foreach (SqlParameter q in cmdParms)
626 {
627 if (q.Direction == ParameterDirection.InputOutput)
628 {
629 q.Value = indentity;
630 }
631 }
632 PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
633 int val = cmd.ExecuteNonQuery();
634 foreach (SqlParameter q in cmdParms)
635 {
636 if (q.Direction == ParameterDirection.Output)
637 {
638 indentity = Convert.ToInt32(q.Value);
639 }
640 }
641 cmd.Parameters.Clear();
642 }
643 trans.Commit();
644 }
645 catch
646 {
647 trans.Rollback();
648 throw;
649 }
650 }
651 }
652 }
653
654 #region 已注释，执行多条SQL语句，实现数据库事务
655
656 /// <summary>
657 /// 执行多条SQL语句，实现数据库事务。
658 /// </summary>
659 /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
660 //public static int ExecuteSqlTran(System.Collections.Generic.List<CommandInfo> cmdList)
661 //{
662 // using (SqlConnection conn = new SqlConnection(connectionString))
663 // {
664 // conn.Open();
665 // using (SqlTransaction trans = conn.BeginTransaction())
666 // {
667 // SqlCommand cmd = new SqlCommand();
668 // try
669 // {
670 // int count = 0;
671 // //循环
672 // foreach (CommandInfo myDE in cmdList)
673 // {
674 // string cmdText = myDE.CommandText;
675 // SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;
676 // PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
677
678 // if (myDE.EffentNextType == EffentNextType.WhenHaveContine || myDE.EffentNextType == EffentNextType.WhenNoHaveContine)
679 // {
680 // if (myDE.CommandText.ToLower().IndexOf("count(") == -1)
681 // {
682 // trans.Rollback();
683 // return 0;
684 // }
685
686 // object obj = cmd.ExecuteScalar();
687 // bool isHave = false;
688 // if (obj == null && obj == DBNull.Value)
689 // {
690 // isHave = false;
691 // }
692 // isHave = Convert.ToInt32(obj) > 0;
693
694 // if (myDE.EffentNextType == EffentNextType.WhenHaveContine && !isHave)
695 // {
696 // trans.Rollback();
697 // return 0;
698 // }
699 // if (myDE.EffentNextType == EffentNextType.WhenNoHaveContine && isHave)
700 // {
701 // trans.Rollback();
702 // return 0;
703 // }
704 // continue;
705 // }
706 // int val = cmd.ExecuteNonQuery();
707 // count += val;
708 // if (myDE.EffentNextType == EffentNextType.ExcuteEffectRows && val == 0)
709 // {
710 // trans.Rollback();
711 // return 0;
712 // }
713 // cmd.Parameters.Clear();
714 // }
715 // trans.Commit();
716 // return count;
717 // }
718 // catch
719 // {
720 // trans.Rollback();
721 // throw;
722 // }
723 // }
724 // }
725 //}
726
727 /// <summary>
728 /// 执行多条SQL语句，实现数据库事务。
729 /// </summary>
730 /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
731 //public static void ExecuteSqlTranWithIndentity(System.Collections.Generic.List<CommandInfo> SQLStringList)
732 //{
733 // using (SqlConnection conn = new SqlConnection(connectionString))
734 // {
735 // conn.Open();
736 // using (SqlTransaction trans = conn.BeginTransaction())
737 // {
738 // SqlCommand cmd = new SqlCommand();
739 // try
740 // {
741 // int indentity = 0;
742 // //循环
743 // foreach (CommandInfo myDE in SQLStringList)
744 // {
745 // string cmdText = myDE.CommandText;
746 // SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;
747 // foreach (SqlParameter q in cmdParms)
748 // {
749 // if (q.Direction == ParameterDirection.InputOutput)
750 // {
751 // q.Value = indentity;
752 // }
753 // }
754 // PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
755 // int val = cmd.ExecuteNonQuery();
756 // foreach (SqlParameter q in cmdParms)
757 // {
758 // if (q.Direction == ParameterDirection.Output)
759 // {
760 // indentity = Convert.ToInt32(q.Value);
761 // }
762 // }
763 // cmd.Parameters.Clear();
764 // }
765 // trans.Commit();
766 // }
767 // catch
768 // {
769 // trans.Rollback();
770 // throw;
771 // }
772 // }
773 // }
774 //}
775
776 #endregion
777
778 /// <summary>
779 /// 执行一条计算查询结果语句，返回查询结果（object）。
780 /// </summary>
781 /// <param name="SQLString">计算查询结果语句</param>
782 /// <returns>查询结果（object）</returns>
783 public static object GetSingle(string SQLString, params SqlParameter[] cmdParms)
784 {
785 using (SqlConnection connection = new SqlConnection(connectionString))
786 {
787 using (SqlCommand cmd = new SqlCommand())
788 {
789 try
790 {
791 PrepareCommand(cmd, connection, null, SQLString, cmdParms);
792 object obj = cmd.ExecuteScalar();
793 cmd.Parameters.Clear();
794 if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
795 {
796 return null;
797 }
798 else
799 {
800 return obj;
801 }
802 }
803 catch (System.Data.SqlClient.SqlException e)
804 {
805 throw e;
806 }
807 }
808 }
809 }
810
811 /// <summary>
812 /// 执行查询语句，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
813 /// </summary>
814 /// <param name="strSQL">查询语句</param>
815 /// <returns>SqlDataReader</returns>
816 public static SqlDataReader ExecuteReader(string SQLString, params SqlParameter[] cmdParms)
817 {
818 SqlConnection connection = new SqlConnection(connectionString);
819 SqlCommand cmd = new SqlCommand();
820 try
821 {
822 PrepareCommand(cmd, connection, null, SQLString, cmdParms);
823 SqlDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
824 cmd.Parameters.Clear();
825 return myReader;
826 }
827 catch (System.Data.SqlClient.SqlException e)
828 {
829 throw e;
830 }
831 // finally
832 // {
833 // cmd.Dispose();
834 // connection.Close();
835 // }
836
837 }
838
839 /// <summary>
840 /// 执行查询语句，返回DataSet
841 /// </summary>
842 /// <param name="SQLString">查询语句</param>
843 /// <returns>DataSet</returns>
844 public static DataSet Query(string SQLString, params SqlParameter[] cmdParms)
845 {
846 using (SqlConnection connection = new SqlConnection(connectionString))
847 {
848 SqlCommand cmd = new SqlCommand();
849 PrepareCommand(cmd, connection, null, SQLString, cmdParms);
850 using (SqlDataAdapter da = new SqlDataAdapter(cmd))
851 {
852 DataSet ds = new DataSet();
853 try
854 {
855 da.Fill(ds, "ds");
856 cmd.Parameters.Clear();
857 }
858 catch (System.Data.SqlClient.SqlException ex)
859 {
860 throw new Exception(ex.Message);
861 }
862 return ds;
863 }
864 }
865 }
866
867
868 private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, string cmdText, SqlParameter[] cmdParms)
869 {
870 if (conn.State != ConnectionState.Open)
871 conn.Open();
872 cmd.Connection = conn;
873 cmd.CommandText = cmdText;
874 if (trans != null)
875 cmd.Transaction = trans;
876 cmd.CommandType = CommandType.Text;//cmdType;
877 if (cmdParms != null)
878 {
879
880
881 foreach (SqlParameter parameter in cmdParms)
882 {
883 if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
884 (parameter.Value == null))
885 {
886 parameter.Value = DBNull.Value;
887 }
888 cmd.Parameters.Add(parameter);
889 }
890 }
891 }
892
893 /// <summary>
894 /// 执行存储过程，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
895 /// </summary>
896 /// <param name="storedProcName">存储过程名</param>
897 /// <param name="parameters">存储过程参数</param>
898 /// <returns>SqlDataReader</returns>
899 public static SqlDataReader RunProcedure(string storedProcName, IDataParameter[] parameters)
900 {
901 SqlConnection connection = new SqlConnection(connectionString);
902 SqlDataReader returnReader;
903 connection.Open();
904 SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
905 command.CommandType = CommandType.StoredProcedure;
906 returnReader = command.ExecuteReader(CommandBehavior.CloseConnection);
907 return returnReader;
908
909 }
910
911 /// <summary>
912 /// 执行存储过程
913 /// </summary>
914 /// <param name="storedProcName">存储过程名</param>
915 /// <param name="parameters">存储过程参数</param>
916 /// <param name="tableName">DataSet结果中的表名</param>
917 /// <returns>DataSet</returns>
918 public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName)
919 {
920 using (SqlConnection connection = new SqlConnection(connectionString))
921 {
922 DataSet dataSet = new DataSet();
923 connection.Open();
924 SqlDataAdapter sqlDA = new SqlDataAdapter();
925 sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
926 sqlDA.Fill(dataSet, tableName);
927 connection.Close();
928 return dataSet;
929 }
930 }
931 public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName, int Times)
932 {
933 using (SqlConnection connection = new SqlConnection(connectionString))
934 {
935 DataSet dataSet = new DataSet();
936 connection.Open();
937 SqlDataAdapter sqlDA = new SqlDataAdapter();
938 sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
939 sqlDA.SelectCommand.CommandTimeout = Times;
940 sqlDA.Fill(dataSet, tableName);
941 connection.Close();
942 return dataSet;
943 }
944 }
945
946 /// <summary>
947 /// 构建 SqlCommand 对象(用来返回一个结果集，而不是一个整数值)
948 /// </summary>
949 /// <param name="connection">数据库连接</param>
950 /// <param name="storedProcName">存储过程名</param>
951 /// <param name="parameters">存储过程参数</param>
952 /// <returns>SqlCommand</returns>
953 private static SqlCommand BuildQueryCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
954 {
955 SqlCommand command = new SqlCommand(storedProcName, connection);
956 command.CommandType = CommandType.StoredProcedure;
957 foreach (SqlParameter parameter in parameters)
958 {
959 if (parameter != null)
960 {
961 // 检查未分配值的输出参数,将其分配以DBNull.Value.
962 if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
963 (parameter.Value == null))
964 {
965 parameter.Value = DBNull.Value;
966 }
967 command.Parameters.Add(parameter);
968 }
969 }
970
971 return command;
972 }
973
974 /// <summary>
975 /// 执行存储过程，返回影响的行数
976 /// </summary>
977 /// <param name="storedProcName">存储过程名</param>
978 /// <param name="parameters">存储过程参数</param>
979 /// <param name="rowsAffected">影响的行数</param>
980 /// <returns></returns>
981 public static int RunProcedure(string storedProcName, IDataParameter[] parameters, out int rowsAffected)
982 {
983 using (SqlConnection connection = new SqlConnection(connectionString))
984 {
985 int result;
986 connection.Open();
987 SqlCommand command = BuildIntCommand(connection, storedProcName, parameters);
988 rowsAffected = command.ExecuteNonQuery();
989 result = (int)command.Parameters["ReturnValue"].Value;
990 //Connection.Close();
991 return result;
992 }
993 }
994
995 /// <summary>
996 /// 创建 SqlCommand 对象实例(用来返回一个整数值)
997 /// </summary>
998 /// <param name="storedProcName">存储过程名</param>
999 /// <param name="parameters">存储过程参数</param>
1000 /// <returns>SqlCommand 对象实例</returns>
1001 private static SqlCommand BuildIntCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
1002 {
1003 SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
1004 command.Parameters.Add(new SqlParameter("ReturnValue",
1005 SqlDbType.Int, 4, ParameterDirection.ReturnValue,
1006 false, 0, 0, string.Empty, DataRowVersion.Default, null));
1007 return command;
1008 }
1009
1010
1011
1012 }
View Code
标签：帮助,return,SqlHelper,cmd,connection,new,SqlConnection,SqlCommand 来源： https://www.cnblogs.com/love201314/p/14886374.html