当前文件： mvcMemberShip/DBUtility/DbHelperSQL.cs[28K，2009-6-12 11:48:02]，打开代码结构图

		            
  1using System;
  2using System.Collections;
  3using System.Collections.Specialized;
  4using System.Data;
  5using System.Data.SqlClient;
  6using System.Configuration;
  7
  8namespace Tmw.DBUtility
  9...{
 10    /**//// <summary>
 11    /// 数据访问抽象基础类
 12    /// Copyright (C) 2004-2008 LiTianPing
 13    /// All rights reserved
 14    /// </summary>
 15    public abstract class DbHelperSQL
 16    ...{
 17        //数据库连接字符串(web.config来配置)
 18        public static string connectionString = ConfigurationManager.ConnectionStrings["fallstarConnection"].ConnectionString;
 19        //public static string connectionString = LTP.Common.DEncrypt.DESEncrypt.Decrypt(LTP.Common.ConfigHelper.GetConfigString("ConnectionString"));
 20        public DbHelperSQL()
 21        ...{
 22        }
 23
 24        公用方法#region 公用方法
 25
 26        public static int GetMaxID(string FieldName, string TableName)
 27        ...{
 28            string strsql = "select max(" + FieldName + ")+1 from " + TableName;
 29            object obj = DbHelperSQL.GetSingle(strsql);
 30            if (obj == null)
 31            ...{
 32                return 1;
 33            }
 34            else
 35            ...{
 36                return int.Parse(obj.ToString());
 37            }
 38        }
 39        public static bool Exists(string strSql)
 40        ...{
 41            object obj = DbHelperSQL.GetSingle(strSql);
 42            int cmdresult;
 43            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
 44            ...{
 45                cmdresult = 0;
 46            }
 47            else
 48            ...{
 49                cmdresult = int.Parse(obj.ToString());
 50            }
 51            if (cmdresult == 0)
 52            ...{
 53                return false;
 54            }
 55            else
 56            ...{
 57                return true;
 58            }
 59        }
 60        public static bool Exists(string strSql, params SqlParameter[] cmdParms)
 61        ...{
 62            object obj = DbHelperSQL.GetSingle(strSql, cmdParms);
 63            int cmdresult;
 64            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
 65            ...{
 66                cmdresult = 0;
 67            }
 68            else
 69            ...{
 70                cmdresult = int.Parse(obj.ToString());
 71            }
 72            if (cmdresult == 0)
 73            ...{
 74                return false;
 75            }
 76            else
 77            ...{
 78                return true;
 79            }
 80        }
 81        #endregion
 82
 83        执行简单SQL语句#region  执行简单SQL语句
 84
 85        /**//// <summary>
 86        /// 执行SQL语句，返回影响的记录数
 87        /// </summary>
 88        /// <param name="SQLString">SQL语句</param>
 89        /// <returns>影响的记录数</returns>
 90        public static int ExecuteSql(string SQLString)
 91        ...{
 92            using (SqlConnection connection = new SqlConnection(connectionString))
 93            ...{
 94                using (SqlCommand cmd = new SqlCommand(SQLString, connection))
 95                ...{
 96                    try
 97                    ...{
 98                        connection.Open();
 99                        int rows = cmd.ExecuteNonQuery();
100                        return rows;
101                    }
102                    catch (System.Data.SqlClient.SqlException E)
103                    ...{
104                        connection.Close();
105                        throw new Exception(E.Message);
106                    }
107                }
108            }
109        }
110
111        /**//// <summary>
112        /// 执行SQL语句，设置命令的执行等待时间
113        /// </summary>
114        /// <param name="SQLString"></param>
115        /// <param name="Times"></param>
116        /// <returns></returns>
117        public static int ExecuteSqlByTime(string SQLString, int Times)
118        ...{
119            using (SqlConnection connection = new SqlConnection(connectionString))
120            ...{
121                using (SqlCommand cmd = new SqlCommand(SQLString, connection))
122                ...{
123                    try
124                    ...{
125                        connection.Open();
126                        cmd.CommandTimeout = Times;
127                        int rows = cmd.ExecuteNonQuery();
128                        return rows;
129                    }
130                    catch (System.Data.SqlClient.SqlException E)
131                    ...{
132                        connection.Close();
133                        throw new Exception(E.Message);
134                    }
135                }
136            }
137        }
138
139        /**//// <summary>
140        /// 执行多条SQL语句，实现数据库事务。
141        /// </summary>
142        /// <param name="SQLStringList">多条SQL语句</param>        
143        public static void ExecuteSqlTran(ArrayList SQLStringList)
144        ...{
145            using (SqlConnection conn = new SqlConnection(connectionString))
146            ...{
147                conn.Open();
148                SqlCommand cmd = new SqlCommand();
149                cmd.Connection = conn;
150                SqlTransaction tx = conn.BeginTransaction();
151                cmd.Transaction = tx;
152                try
153                ...{
154                    for (int n = 0; n < SQLStringList.Count; n++)
155                    ...{
156                        string strsql = SQLStringList[n].ToString();
157                        if (strsql.Trim().Length > 1)
158                        ...{
159                            cmd.CommandText = strsql;
160                            cmd.ExecuteNonQuery();
161                        }
162                    }
163                    tx.Commit();
164                }
165                catch (System.Data.SqlClient.SqlException E)
166                ...{
167                    tx.Rollback();
168                    throw new Exception(E.Message);
169                }
170            }
171        }
172        /**//// <summary>
173        /// 执行带一个存储过程参数的的SQL语句。
174        /// </summary>
175        /// <param name="SQLString">SQL语句</param>
176        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
177        /// <returns>影响的记录数</returns>
178        public static int ExecuteSql(string SQLString, string content)
179        ...{
180            using (SqlConnection connection = new SqlConnection(connectionString))
181            ...{
182                SqlCommand cmd = new SqlCommand(SQLString, connection);
183                System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
184                myParameter.Value = content;
185                cmd.Parameters.Add(myParameter);
186                try
187                ...{
188                    connection.Open();
189                    int rows = cmd.ExecuteNonQuery();
190                    return rows;
191                }
192                catch (System.Data.SqlClient.SqlException E)
193                ...{
194                    throw new Exception(E.Message);
195                }
196                finally
197                ...{
198                    cmd.Dispose();
199                    connection.Close();
200                }
201            }
202        }
203        /**//// <summary>
204        /// 执行带一个存储过程参数的的SQL语句。
205        /// </summary>
206        /// <param name="SQLString">SQL语句</param>
207        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
208        /// <returns>影响的记录数</returns>
209        public static object ExecuteSqlGet(string SQLString, string content)
210        ...{
211            using (SqlConnection connection = new SqlConnection(connectionString))
212            ...{
213                SqlCommand cmd = new SqlCommand(SQLString, connection);
214                System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
215                myParameter.Value = content;
216                cmd.Parameters.Add(myParameter);
217                try
218                ...{
219                    connection.Open();
220                    object obj = cmd.ExecuteScalar();
221                    if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
222                    ...{
223                        return null;
224                    }
225                    else
226                    ...{
227                        return obj;
228                    }
229                }
230                catch (System.Data.SqlClient.SqlException E)
231                ...{
232                    throw new Exception(E.Message);
233                }
234                finally
235                ...{
236                    cmd.Dispose();
237                    connection.Close();
238                }
239            }
240        }
241        /**//// <summary>
242        /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
243        /// </summary>
244        /// <param name="strSQL">SQL语句</param>
245        /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
246        /// <returns>影响的记录数</returns>
247        public static int ExecuteSqlInsertImg(string strSQL, byte[] fs)
248        ...{
249            using (SqlConnection connection = new SqlConnection(connectionString))
250            ...{
251                SqlCommand cmd = new SqlCommand(strSQL, connection);
252                System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@fs", SqlDbType.Image);
253                myParameter.Value = fs;
254                cmd.Parameters.Add(myParameter);
255                try
256                ...{
257                    connection.Open();
258                    int rows = cmd.ExecuteNonQuery();
259                    return rows;
260                }
261                catch (System.Data.SqlClient.SqlException E)
262                ...{
263                    throw new Exception(E.Message);
264                }
265                finally
266                ...{
267                    cmd.Dispose();
268                    connection.Close();
269                }
270            }
271        }
272
273        /**//// <summary>
274        /// 执行一条计算查询结果语句，返回查询结果（object）。
275        /// </summary>
276        /// <param name="SQLString">计算查询结果语句</param>
277        /// <returns>查询结果（object）</returns>
278        public static object GetSingle(string SQLString)
279        ...{
280            using (SqlConnection connection = new SqlConnection(connectionString))
281            ...{
282                using (SqlCommand cmd = new SqlCommand(SQLString, connection))
283                ...{
284                    try
285                    ...{
286                        connection.Open();
287                        object obj = cmd.ExecuteScalar();
288                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
289                        ...{
290                            return null;
291                        }
292                        else
293                        ...{
294                            return obj;
295                        }
296                    }
297                    catch (System.Data.SqlClient.SqlException e)
298                    ...{
299                        connection.Close();
300                        throw new Exception(e.Message);
301                    }
302                }
303            }
304        }
305
306
307        /**//// <summary>
308        /// 执行查询语句，返回SqlDataReader(使用该方法切记要手工关闭SqlDataReader和连接)
309        /// </summary>
310        /// <param name="strSQL">查询语句</param>
311        /// <returns>SqlDataReader</returns>
312        public static SqlDataReader ExecuteReader(string strSQL)
313        ...{
314            SqlConnection connection = new SqlConnection(connectionString);
315            SqlCommand cmd = new SqlCommand(strSQL, connection);
316            try
317            ...{
318                connection.Open();
319                SqlDataReader myReader = cmd.ExecuteReader();
320                return myReader;
321            }
322            catch (System.Data.SqlClient.SqlException e)
323            ...{
324                throw new Exception(e.Message);
325            }
326            //finally //不能在此关闭，否则，返回的对象将无法使用
327            //{
328            //    cmd.Dispose();
329            //    connection.Close();
330            //}    
331
332
333        }
334        /**//// <summary>
335        /// 执行查询语句，返回DataSet
336        /// </summary>
337        /// <param name="SQLString">查询语句</param>
338        /// <returns>DataSet</returns>
339        public static DataSet Query(string SQLString)
340        ...{
341            using (SqlConnection connection = new SqlConnection(connectionString))
342            ...{
343                DataSet ds = new DataSet();
344                try
345                ...{
346                    connection.Open();
347                    SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
348                    command.Fill(ds, "ds");
349                }
350                catch (System.Data.SqlClient.SqlException ex)
351                ...{
352                    throw new Exception(ex.Message);
353                }
354                return ds;
355            }
356        }
357        public static DataSet Query(string SQLString, string TableName)
358        ...{
359            using (SqlConnection connection = new SqlConnection(connectionString))
360            ...{
361                DataSet ds = new DataSet();
362                try
363                ...{
364                    connection.Open();
365                    SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
366                    command.Fill(ds, TableName);
367                }
368                catch (System.Data.SqlClient.SqlException ex)
369                ...{
370                    throw new Exception(ex.Message);
371                }
372                return ds;
373            }
374        }
375        /**//// <summary>
376        /// 执行查询语句，返回DataSet,设置命令的执行等待时间
377        /// </summary>
378        /// <param name="SQLString"></param>
379        /// <param name="Times"></param>
380        /// <returns></returns>
381        public static DataSet Query(string SQLString, int Times)
382        ...{
383            using (SqlConnection connection = new SqlConnection(connectionString))
384            ...{
385                DataSet ds = new DataSet();
386                try
387                ...{
388                    connection.Open();
389                    SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
390                    command.SelectCommand.CommandTimeout = Times;
391                    command.Fill(ds, "ds");
392                }
393                catch (System.Data.SqlClient.SqlException ex)
394                ...{
395                    throw new Exception(ex.Message);
396                }
397                return ds;
398            }
399        }
400
401
402
403        #endregion
404
405        执行带参数的SQL语句#region 执行带参数的SQL语句
406
407        /**//// <summary>
408        /// 执行SQL语句，返回影响的记录数
409        /// </summary>
410        /// <param name="SQLString">SQL语句</param>
411        /// <returns>影响的记录数</returns>
412        public static int ExecuteSql(string SQLString, params SqlParameter[] cmdParms)
413        ...{
414            using (SqlConnection connection = new SqlConnection(connectionString))
415            ...{
416                using (SqlCommand cmd = new SqlCommand())
417                ...{
418                    try
419                    ...{
420                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
421                        int rows = cmd.ExecuteNonQuery();
422                        cmd.Parameters.Clear();
423                        return rows;
424                    }
425                    catch (System.Data.SqlClient.SqlException E)
426                    ...{
427                        throw new Exception(E.Message);
428                    }
429                }
430            }
431        }
432
433
434        /**//// <summary>
435        /// 执行多条SQL语句，实现数据库事务。
436        /// </summary>
437        /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
438        public static void ExecuteSqlTran(Hashtable SQLStringList)
439        ...{
440            using (SqlConnection conn = new SqlConnection(connectionString))
441            ...{
442                conn.Open();
443                using (SqlTransaction trans = conn.BeginTransaction())
444                ...{
445                    SqlCommand cmd = new SqlCommand();
446                    try
447                    ...{
448                        //循环
449                        foreach (DictionaryEntry myDE in SQLStringList)
450                        ...{
451                            string cmdText = myDE.Key.ToString();
452                            SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
453                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
454                            int val = cmd.ExecuteNonQuery();
455                            cmd.Parameters.Clear();
456
457                            trans.Commit();
458                        }
459                    }
460                    catch
461                    ...{
462                        trans.Rollback();
463                        throw;
464                    }
465                }
466            }
467        }
468
469
470        /**//// <summary>
471        /// 执行一条计算查询结果语句，返回查询结果（object）。
472        /// </summary>
473        /// <param name="SQLString">计算查询结果语句</param>
474        /// <returns>查询结果（object）</returns>
475        public static object GetSingle(string SQLString, params SqlParameter[] cmdParms)
476        ...{
477            using (SqlConnection connection = new SqlConnection(connectionString))
478            ...{
479                using (SqlCommand cmd = new SqlCommand())
480                ...{
481                    try
482                    ...{
483                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
484                        object obj = cmd.ExecuteScalar();
485                        cmd.Parameters.Clear();
486                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
487                        ...{
488                            return null;
489                        }
490                        else
491                        ...{
492                            return obj;
493                        }
494                    }
495                    catch (System.Data.SqlClient.SqlException e)
496                    ...{
497                        throw new Exception(e.Message);
498                    }
499                }
500            }
501        }
502
503        /**//// <summary>
504        /// 执行查询语句，返回SqlDataReader (使用该方法切记要手工关闭SqlDataReader和连接)
505        /// </summary>
506        /// <param name="strSQL">查询语句</param>
507        /// <returns>SqlDataReader</returns>
508        public static SqlDataReader ExecuteReader(string SQLString, params SqlParameter[] cmdParms)
509        ...{
510            SqlConnection connection = new SqlConnection(connectionString);
511            SqlCommand cmd = new SqlCommand();
512            try
513            ...{
514                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
515                SqlDataReader myReader = cmd.ExecuteReader();
516                cmd.Parameters.Clear();
517                return myReader;
518            }
519            catch (System.Data.SqlClient.SqlException e)
520            ...{
521                throw new Exception(e.Message);
522            }
523            //finally //不能在此关闭，否则，返回的对象将无法使用
524            //{
525            //    cmd.Dispose();
526            //    connection.Close();
527            //}    
528
529        }
530
531        /**//// <summary>
532        /// 执行查询语句，返回DataSet
533        /// </summary>
534        /// <param name="SQLString">查询语句</param>
535        /// <returns>DataSet</returns>
536        public static DataSet Query(string SQLString, params SqlParameter[] cmdParms)
537        ...{
538            using (SqlConnection connection = new SqlConnection(connectionString))
539            ...{
540                SqlCommand cmd = new SqlCommand();
541                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
542                using (SqlDataAdapter da = new SqlDataAdapter(cmd))
543                ...{
544                    DataSet ds = new DataSet();
545                    try
546                    ...{
547                        da.Fill(ds, "ds");
548                        cmd.Parameters.Clear();
549                    }
550                    catch (System.Data.SqlClient.SqlException ex)
551                    ...{
552                        throw new Exception(ex.Message);
553                    }
554                    return ds;
555                }
556            }
557        }
558
559
560        private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, string cmdText, SqlParameter[] cmdParms)
561        ...{
562            if (conn.State != ConnectionState.Open)
563                conn.Open();
564            cmd.Connection = conn;
565            cmd.CommandText = cmdText;
566            if (trans != null)
567                cmd.Transaction = trans;
568            cmd.CommandType = CommandType.Text;//cmdType;
569            if (cmdParms != null)
570            ...{
571
572
573                foreach (SqlParameter parameter in cmdParms)
574                ...{
575                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
576                        (parameter.Value == null))
577                    ...{
578                        parameter.Value = DBNull.Value;
579                    }
580                    cmd.Parameters.Add(parameter);
581                }
582            }
583        }
584
585        #endregion
586
587        存储过程操作#region 存储过程操作
588
589        /**//// <summary>
590        /// 执行存储过程  (使用该方法切记要手工关闭SqlDataReader和连接)
591        /// </summary>
592        /// <param name="storedProcName">存储过程名</param>
593        /// <param name="parameters">存储过程参数</param>
594        /// <returns>SqlDataReader</returns>
595        public static SqlDataReader RunProcedure(string storedProcName, IDataParameter[] parameters)
596        ...{
597            SqlConnection connection = new SqlConnection(connectionString);
598            SqlDataReader returnReader;
599            connection.Open();
600            SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
601            command.CommandType = CommandType.StoredProcedure;
602            returnReader = command.ExecuteReader();
603            //Connection.Close(); 不能在此关闭，否则，返回的对象将无法使用            
604            return returnReader;
605
606        }
607        /**//// <summary>
608        /// 执行存储过程
609        /// </summary>
610        /// <param name="storedProcName">存储过程名</param>
611        /// <param name="parameters">存储过程参数</param>
612        /// <returns>结果中第一行第一列</returns>
613        public string RunProc(string storedProcName, IDataParameter[] parameters)
614        ...{
615            using (SqlConnection connection = new SqlConnection(connectionString))
616            ...{
617                string StrValue;
618                connection.Open();
619                SqlCommand cmd;
620                cmd = BuildQueryCommand(connection, storedProcName, parameters);
621                StrValue = cmd.ExecuteScalar().ToString();
622                connection.Close();
623                return StrValue;
624            }
625        }
626
627        /**//// <summary>
628        /// 执行存储过程
629        /// </summary>
630        /// <param name="storedProcName">存储过程名</param>
631        /// <param name="parameters">存储过程参数</param>
632        /// <param name="tableName">DataSet结果中的表名</param>
633        /// <returns>DataSet</returns>
634        public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName)
635        ...{
636            using (SqlConnection connection = new SqlConnection(connectionString))
637            ...{
638                DataSet dataSet = new DataSet();
639                connection.Open();
640                SqlDataAdapter sqlDA = new SqlDataAdapter();
641                sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
642                sqlDA.Fill(dataSet, tableName);
643                connection.Close();
644                return dataSet;
645            }
646        }
647        public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName, int Times)
648        ...{
649            using (SqlConnection connection = new SqlConnection(connectionString))
650            ...{
651                DataSet dataSet = new DataSet();
652                connection.Open();
653                SqlDataAdapter sqlDA = new SqlDataAdapter();
654                sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
655                sqlDA.SelectCommand.CommandTimeout = Times;
656                sqlDA.Fill(dataSet, tableName);
657                connection.Close();
658                return dataSet;
659            }
660        }
661
662
663        /**//// <summary>
664        /// 构建 SqlCommand 对象(用来返回一个结果集，而不是一个整数值)
665        /// </summary>
666        /// <param name="connection">数据库连接</param>
667        /// <param name="storedProcName">存储过程名</param>
668        /// <param name="parameters">存储过程参数</param>
669        /// <returns>SqlCommand</returns>
670        private static SqlCommand BuildQueryCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
671        ...{
672            SqlCommand command = new SqlCommand(storedProcName, connection);
673            command.CommandType = CommandType.StoredProcedure;
674            foreach (SqlParameter parameter in parameters)
675            ...{
676                if (parameter != null)
677                ...{
678                    // 检查未分配值的输出参数,将其分配以DBNull.Value.
679                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
680                        (parameter.Value == null))
681                    ...{
682                        parameter.Value = DBNull.Value;
683                    }
684                    command.Parameters.Add(parameter);
685                }
686            }
687
688            return command;
689        }
690
691        /**//// <summary>
692        /// 执行存储过程，返回影响的行数        
693        /// </summary>
694        /// <param name="storedProcName">存储过程名</param>
695        /// <param name="parameters">存储过程参数</param>
696        /// <param name="rowsAffected">影响的行数</param>
697        /// <returns></returns>
698        public static int RunProcedure(string storedProcName, IDataParameter[] parameters, out int rowsAffected)
699        ...{
700            using (SqlConnection connection = new SqlConnection(connectionString))
701            ...{
702                int result;
703                connection.Open();
704                SqlCommand command = BuildIntCommand(connection, storedProcName, parameters);
705                rowsAffected = command.ExecuteNonQuery();
706                result = (int)command.Parameters["ReturnValue"].Value;
707                //Connection.Close();
708                return result;
709            }
710        }
711
712        /**//// <summary>
713        /// 创建 SqlCommand 对象实例(用来返回一个整数值)    
714        /// </summary>
715        /// <param name="storedProcName">存储过程名</param>
716        /// <param name="parameters">存储过程参数</param>
717        /// <returns>SqlCommand 对象实例</returns>
718        private static SqlCommand BuildIntCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
719        ...{
720            SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
721            command.Parameters.Add(new SqlParameter("ReturnValue",
722                SqlDbType.Int, 4, ParameterDirection.ReturnValue,
723                false, 0, 0, string.Empty, DataRowVersion.Default, null));
724            return command;
725        }
726        /**//// <summary>
727        /// 执行SQL语句
728        /// </summary>
729        /// <param name="storedProcName">存储过程名</param>
730        /// <param name="parameters">存储过程参数</param>
731        /// <returns>结果中第一行第一列</returns>
732        public static string RunSql(string query)
733        ...{
734            string str;
735            using (SqlConnection connection = new SqlConnection(connectionString))
736            ...{
737                using (SqlCommand cmd = new SqlCommand(query, connection))
738                ...{
739                    try
740                    ...{
741                        connection.Open();
742                        str = (cmd.ExecuteScalar().ToString()=="")?"":cmd.ExecuteScalar().ToString();                      
743                        return str;
744                    }
745                    catch (System.Data.SqlClient.SqlException E)
746                    ...{
747                        connection.Close();
748                        throw new Exception(E.Message);
749                    }
750                }
751            }
752        }
753        #endregion
754
755    }
756}
757