微软SQLHelper.cs类 中文版

原文地址为： 微软SQLHelper.cs类 中文版

   1 using System; 
   2 using System.Data; 
   3 using System.Xml; 
   4 using System.Data.SqlClient; 
   5 using System.Collections; 
   6 using System.Configuration;
   7 
   8 namespace BookDAL 
   9 { 
  10     /// 
 
  11     /// SqlServer数据访问帮助类 
  12     ///  
  13     public sealed class SqlHelper 
  14     { 
  15         #region 私有构造函数和方法
  16 
  17         private SqlHelper() { }
  18 
  19         /// 
 
  20         /// 将SqlParameter参数数组(参数值)分配给SqlCommand命令. 
  21         /// 这个方法将给任何一个参数分配DBNull.Value; 
  22         /// 该操作将阻止默认值的使用. 
  23         ///  
  24         /// 命令名 
  25         /// SqlParameters数组 
  26         private static void AttachParameters(SqlCommand command, SqlParameter[] commandParameters) 
  27         { 
  28             if (command == null) throw new ArgumentNullException("command"); 
  29             if (commandParameters != null) 
  30             { 
  31                 foreach (SqlParameter p in commandParameters) 
  32                 { 
  33                     if (p != null) 
  34                     { 
  35                         // 检查未分配值的输出参数,将其分配以DBNull.Value. 
  36                         if ((p.Direction == ParameterDirection.InputOutput || p.Direction == ParameterDirection.Input) && 
  37                             (p.Value == null)) 
  38                         { 
  39                             p.Value = DBNull.Value; 
  40                         } 
  41                         command.Parameters.Add(p); 
  42                     } 
  43                 } 
  44             } 
  45         }
  46 
  47         /// 
 
  48         /// 将DataRow类型的列值分配到SqlParameter参数数组. 
  49         ///  
  50         /// 要分配值的SqlParameter参数数组 
  51         /// 将要分配给存储过程参数的DataRow 
  52         private static void AssignParameterValues(SqlParameter[] commandParameters, DataRow dataRow) 
  53         { 
  54             if ((commandParameters == null) || (dataRow == null)) 
  55             { 
  56                 return; 
  57             }
  58 
  59             int i = 0; 
  60             // 设置参数值 
  61             foreach (SqlParameter commandParameter in commandParameters) 
  62             { 
  63                 // 创建参数名称,如果不存在,只抛出一个异常. 
  64                 if (commandParameter.ParameterName == null || 
  65                     commandParameter.ParameterName.Length <= 1) 
  66                     throw new Exception( 
  67                         string.Format("请提供参数{0}一个有效的名称{1}.", i, commandParameter.ParameterName)); 
  68                 // 从dataRow的表中获取为参数数组中数组名称的列的索引. 
  69                 // 如果存在和参数名称相同的列,则将列值赋给当前名称的参数. 
  70                 if (dataRow.Table.Columns.IndexOf(commandParameter.ParameterName.Substring(1)) != -1) 
  71                     commandParameter.Value = dataRow[commandParameter.ParameterName.Substring(1)]; 
  72                 i++; 
  73             } 
  74         }
  75 
  76         /// 
 
  77         /// 将一个对象数组分配给SqlParameter参数数组. 
  78         ///  
  79         /// 要分配值的SqlParameter参数数组 
  80         /// 将要分配给存储过程参数的对象数组 
  81         private static void AssignParameterValues(SqlParameter[] commandParameters, object[] parameterValues) 
  82         { 
  83             if ((commandParameters == null) || (parameterValues == null)) 
  84             { 
  85                 return; 
  86             }
  87 
  88             // 确保对象数组个数与参数个数匹配,如果不匹配,抛出一个异常. 
  89             if (commandParameters.Length != parameterValues.Length) 
  90             { 
  91                 throw new ArgumentException("参数值个数与参数不匹配."); 
  92             }
  93 
  94             // 给参数赋值 
  95             for (int i = 0, j = commandParameters.Length; i < j; i++) 
  96             { 
  97                 // If the current array value derives from IDbDataParameter, then assign its Value property 
  98                 if (parameterValues[i] is IDbDataParameter) 
  99                 { 
 100                     IDbDataParameter paramInstance = (IDbDataParameter)parameterValues[i]; 
 101                     if (paramInstance.Value == null) 
 102                     { 
 103                         commandParameters[i].Value = DBNull.Value; 
 104                     } 
 105                     else 
 106                     { 
 107                         commandParameters[i].Value = paramInstance.Value; 
 108                     } 
 109                 } 
 110                 else if (parameterValues[i] == null) 
 111                 { 
 112                     commandParameters[i].Value = DBNull.Value; 
 113                 } 
 114                 else 
 115                 { 
 116                     commandParameters[i].Value = parameterValues[i]; 
 117                 } 
 118             } 
 119         }
 120 
 121         /// 
 
 122         /// 预处理用户提供的命令,数据库连接/事务/命令类型/参数 
 123         ///  
 124         /// 要处理的SqlCommand 
 125         /// 数据库连接 
 126         /// 一个有效的事务或者是null值 
 127         /// 命令类型 (存储过程,命令文本, 其它.) 
 128         /// 存储过程名或都T-SQL命令文本 
 129         /// 和命令相关联的SqlParameter参数数组,如果没有参数为'null' 
 130         /// true 如果连接是打开的,则为true,其它情况下为false. 
 131         private static void PrepareCommand(SqlCommand command, SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters, out bool mustCloseConnection) 
 132         { 
 133             if (command == null) throw new ArgumentNullException("command"); 
 134             if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText");
 135 
 136             // If the provided connection is not open, we will open it 
 137             if (connection.State != ConnectionState.Open) 
 138             { 
 139                 mustCloseConnection = true; 
 140                 connection.Open(); 
 141             } 
 142             else 
 143             { 
 144                 mustCloseConnection = false; 
 145             }
 146 
 147             // 给命令分配一个数据库连接. 
 148             command.Connection = connection;
 149 
 150             // 设置命令文本(存储过程名或SQL语句) 
 151             command.CommandText = commandText;
 152 
 153             // 分配事务 
 154             if (transaction != null) 
 155             { 
 156                 if (transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 
 157                 command.Transaction = transaction; 
 158             }
 159 
 160             // 设置命令类型. 
 161             command.CommandType = commandType;
 162 
 163             // 分配命令参数 
 164             if (commandParameters != null) 
 165             { 
 166                 AttachParameters(command, commandParameters); 
 167             } 
 168             return; 
 169         }
 170 
 171         #endregion 私有构造函数和方法结束
 172 
 173         #region 数据库连接 
 174         /// 
 
 175         /// 一个有效的数据库连接字符串 
 176         ///  
 177         ///  
 178         public static string GetConnSting() 
 179         { 
 180             return ConfigurationManager.ConnectionStrings["ConStr"].ConnectionString; 
 181         } 
 182         /// 
 
 183         /// 一个有效的数据库连接对象 
 184         ///  
 185         ///  
 186         public static SqlConnection GetConnection() 
 187         { 
 188             SqlConnection Connection = new SqlConnection(SqlHelper.GetConnSting()); 
 189             return Connection; 
 190         } 
 191         #endregion
 192 
 193         #region ExecuteNonQuery命令
 194 
 195         /// 
 
 196         /// 执行指定连接字符串,类型的SqlCommand. 
 197         ///  
 198         ///  
 199         /// 示例:  
 200         ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders"); 
 201         ///  
 202         /// 一个有效的数据库连接字符串 
 203         /// 命令类型 (存储过程,命令文本, 其它.) 
 204         /// 存储过程名称或SQL语句 
 205         /// 返回命令影响的行数 
 206         public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText) 
 207         { 
 208             return ExecuteNonQuery(connectionString, commandType, commandText, (SqlParameter[])null); 
 209         }
 210 
 211         /// 
 
 212         /// 执行指定连接字符串,类型的SqlCommand.如果没有提供参数,不返回结果. 
 213         ///  
 214         ///  
 215         /// 示例:  
 216         ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24)); 
 217         ///  
 218         /// 一个有效的数据库连接字符串 
 219         /// 命令类型 (存储过程,命令文本, 其它.) 
 220         /// 存储过程名称或SQL语句 
 221         /// SqlParameter参数数组 
 222         /// 返回命令影响的行数 
 223         public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 
 224         { 
 225             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
 226 
 227             using (SqlConnection connection = new SqlConnection(connectionString)) 
 228             { 
 229                 connection.Open();
 230 
 231                 return ExecuteNonQuery(connection, commandType, commandText, commandParameters); 
 232             } 
 233         }
 234 
 235         /// 
 
 236         /// 执行指定连接字符串的存储过程,将对象数组的值赋给存储过程参数, 
 237         /// 此方法需要在参数缓存方法中探索参数并生成参数. 
 238         ///  
 239         ///  
 240         /// 这个方法没有提供访问输出参数和返回值. 
 241         /// 示例:  
 242         ///  int result = ExecuteNonQuery(connString, "PublishOrders", 24, 36); 
 243         ///  
 244         /// 一个有效的数据库连接字符串/param> 
 245         /// 存储过程名称 
 246         /// 分配到存储过程输入参数的对象数组 
 247         /// 返回受影响的行数 
 248         public static int ExecuteNonQuery(string connectionString, string spName, params object[] parameterValues) 
 249         { 
 250             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 
 251             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
 252 
 253             // 如果存在参数值 
 254             if ((parameterValues != null) && (parameterValues.Length > 0)) 
 255             { 
 256                 // 从探索存储过程参数(加载到缓存)并分配给存储过程参数数组. 
 257                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
 258 
 259                 // 给存储过程参数赋值 
 260                 AssignParameterValues(commandParameters, parameterValues);
 261 
 262                 return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters); 
 263             } 
 264             else 
 265             { 
 266                 // 没有参数情况下 
 267                 return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName); 
 268             } 
 269         }
 270 
 271         /// 
 
 272         /// 执行指定数据库连接对象的命令 
 273         ///  
 274         ///  
 275         /// 示例:  
 276         ///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders"); 
 277         ///  
 278         /// 一个有效的数据库连接对象 
 279         /// 命令类型(存储过程,命令文本或其它.) 
 280         /// 存储过程名称或T-SQL语句 
 281         /// 返回影响的行数 
 282         public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText) 
 283         { 
 284             return ExecuteNonQuery(connection, commandType, commandText, (SqlParameter[])null); 
 285         }
 286 
 287         /// 
 
 288         /// 执行指定数据库连接对象的命令 
 289         ///  
 290         ///  
 291         /// 示例:  
 292         ///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24)); 
 293         ///  
 294         /// 一个有效的数据库连接对象 
 295         /// 命令类型(存储过程,命令文本或其它.) 
 296         /// T存储过程名称或T-SQL语句 
 297         /// SqlParamter参数数组 
 298         /// 返回影响的行数 
 299         public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 
 300         { 
 301             if (connection == null) throw new ArgumentNullException("connection");
 302 
 303             // 创建SqlCommand命令,并进行预处理 
 304             SqlCommand cmd = new SqlCommand(); 
 305             bool mustCloseConnection = false; 
 306             PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
 307 
 308             // Finally, execute the command 
 309             int retval = cmd.ExecuteNonQuery();
 310 
 311             // 清除参数,以便再次使用. 
 312             cmd.Parameters.Clear(); 
 313             if (mustCloseConnection) 
 314                 connection.Close(); 
 315             return retval; 
 316         }
 317 
 318         /// 
 
 319         /// 执行指定数据库连接对象的命令,将对象数组的值赋给存储过程参数. 
 320         ///  
 321         ///  
 322         /// 此方法不提供访问存储过程输出参数和返回值 
 323         /// 示例:  
 324         ///  int result = ExecuteNonQuery(conn, "PublishOrders", 24, 36); 
 325         ///  
 326         /// 一个有效的数据库连接对象 
 327         /// 存储过程名 
 328         /// 分配给存储过程输入参数的对象数组 
 329         /// 返回影响的行数 
 330         public static int ExecuteNonQuery(SqlConnection connection, string spName, params object[] parameterValues) 
 331         { 
 332             if (connection == null) throw new ArgumentNullException("connection"); 
 333             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
 334 
 335             // 如果有参数值 
 336             if ((parameterValues != null) && (parameterValues.Length > 0)) 
 337             { 
 338                 // 从缓存中加载存储过程参数 
 339                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
 340 
 341                 // 给存储过程分配参数值 
 342                 AssignParameterValues(commandParameters, parameterValues);
 343 
 344                 return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters); 
 345             } 
 346             else 
 347             { 
 348                 return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName); 
 349             } 
 350         }
 351 
 352         /// 
 
 353         /// 执行带事务的SqlCommand. 
 354         ///  
 355         ///  
 356         /// 示例.:  
 357         ///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders"); 
 358         ///  
 359         /// 一个有效的数据库连接对象 
 360         /// 命令类型(存储过程,命令文本或其它.) 
 361         /// 存储过程名称或T-SQL语句 
 362         /// 返回影响的行数/returns> 
 363         public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText) 
 364         { 
 365             return ExecuteNonQuery(transaction, commandType, commandText, (SqlParameter[])null); 
 366         }
 367 
 368         /// 
 
 369         /// 执行带事务的SqlCommand(指定参数). 
 370         ///  
 371         ///  
 372         /// 示例:  
 373         ///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 
 374         ///  
 375         /// 一个有效的数据库连接对象 
 376         /// 命令类型(存储过程,命令文本或其它.) 
 377         /// 存储过程名称或T-SQL语句 
 378         /// SqlParamter参数数组 
 379         /// 返回影响的行数 
 380         public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 
 381         { 
 382             if (transaction == null) throw new ArgumentNullException("transaction"); 
 383             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
 384 
 385             // 预处理 
 386             SqlCommand cmd = new SqlCommand(); 
 387             bool mustCloseConnection = false; 
 388             PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
 389 
 390             // 执行 
 391             int retval = cmd.ExecuteNonQuery();
 392 
 393             // 清除参数集,以便再次使用. 
 394             cmd.Parameters.Clear(); 
 395             return retval; 
 396         }
 397 
 398         /// 
 
 399         /// 执行带事务的SqlCommand(指定参数值). 
 400         ///  
 401         ///  
 402         /// 此方法不提供访问存储过程输出参数和返回值 
 403         /// 示例:  
 404         ///  int result = ExecuteNonQuery(conn, trans, "PublishOrders", 24, 36); 
 405         ///  
 406         /// 一个有效的数据库连接对象 
 407         /// 存储过程名 
 408         /// 分配给存储过程输入参数的对象数组 
 409         /// 返回受影响的行数 
 410         public static int ExecuteNonQuery(SqlTransaction transaction, string spName, params object[] parameterValues) 
 411         { 
 412             if (transaction == null) throw new ArgumentNullException("transaction"); 
 413             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 
 414             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
 415 
 416             // 如果有参数值 
 417             if ((parameterValues != null) && (parameterValues.Length > 0)) 
 418             { 
 419                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
 420                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
 421 
 422                 // 给存储过程参数赋值 
 423                 AssignParameterValues(commandParameters, parameterValues);
 424 
 425                 // 调用重载方法 
 426                 return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters); 
 427             } 
 428             else 
 429             { 
 430                 // 没有参数值 
 431                 return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName); 
 432             } 
 433         }
 434 
 435         #endregion ExecuteNonQuery方法结束
 436 
 437         #region ExecuteDataset方法
 438 
 439         /// 
 
 440         /// 执行指定数据库连接字符串的命令,返回DataSet. 
 441         ///  
 442         ///  
 443         /// 示例:  
 444         ///  DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders"); 
 445         ///  
 446         /// 一个有效的数据库连接字符串 
 447         /// 命令类型 (存储过程,命令文本或其它) 
 448         /// 存储过程名称或T-SQL语句 
 449         /// 返回一个包含结果集的DataSet 
 450         public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText) 
 451         { 
 452             return ExecuteDataset(connectionString, commandType, commandText, (SqlParameter[])null); 
 453         }
 454 
 455         /// 
 
 456         /// 执行指定数据库连接字符串的命令,返回DataSet. 
 457         ///  
 458         ///  
 459         /// 示例: 
 460         ///  DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 
 461         ///  
 462         /// 一个有效的数据库连接字符串 
 463         /// 命令类型 (存储过程,命令文本或其它) 
 464         /// 存储过程名称或T-SQL语句 
 465         /// SqlParamters参数数组 
 466         /// 返回一个包含结果集的DataSet 
 467         public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 
 468         { 
 469             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
 470 
 471             // 创建并打开数据库连接对象,操作完成释放对象. 
 472             using (SqlConnection connection = new SqlConnection(connectionString)) 
 473             { 
 474                 connection.Open();
 475 
 476                 // 调用指定数据库连接字符串重载方法. 
 477                 return ExecuteDataset(connection, commandType, commandText, commandParameters); 
 478             } 
 479         }
 480 
 481         /// 
 
 482         /// 执行指定数据库连接字符串的命令,直接提供参数值,返回DataSet. 
 483         ///  
 484         ///  
 485         /// 此方法不提供访问存储过程输出参数和返回值. 
 486         /// 示例: 
 487         ///  DataSet ds = ExecuteDataset(connString, "GetOrders", 24, 36); 
 488         ///  
 489         /// 一个有效的数据库连接字符串 
 490         /// 存储过程名 
 491         /// 分配给存储过程输入参数的对象数组 
 492         /// 返回一个包含结果集的DataSet 
 493         public static DataSet ExecuteDataset(string connectionString, string spName, params object[] parameterValues) 
 494         { 
 495             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 
 496             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
 497 
 498             if ((parameterValues != null) && (parameterValues.Length > 0)) 
 499             { 
 500                 // 从缓存中检索存储过程参数 
 501                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
 502 
 503                 // 给存储过程参数分配值 
 504                 AssignParameterValues(commandParameters, parameterValues);
 505 
 506                 return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters); 
 507             } 
 508             else 
 509             { 
 510                 return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName); 
 511             } 
 512         }
 513 
 514         /// 
 
 515         /// 执行指定数据库连接对象的命令,返回DataSet. 
 516         ///  
 517         ///  
 518         /// 示例:  
 519         ///  DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders"); 
 520         ///  
 521         /// 一个有效的数据库连接对象 
 522         /// 命令类型 (存储过程,命令文本或其它) 
 523         /// 存储过程名或T-SQL语句 
 524         /// 返回一个包含结果集的DataSet 
 525         public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText) 
 526         { 
 527             return ExecuteDataset(connection, commandType, commandText, (SqlParameter[])null); 
 528         }
 529 
 530         /// 
 
 531         /// 执行指定数据库连接对象的命令,指定存储过程参数,返回DataSet. 
 532         ///  
 533         ///  
 534         /// 示例:  
 535         ///  DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 
 536         ///  
 537         /// 一个有效的数据库连接对象 
 538         /// 命令类型 (存储过程,命令文本或其它) 
 539         /// 存储过程名或T-SQL语句 
 540         /// SqlParamter参数数组 
 541         /// 返回一个包含结果集的DataSet 
 542         public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 
 543         { 
 544             if (connection == null) throw new ArgumentNullException("connection");
 545 
 546             // 预处理 
 547             SqlCommand cmd = new SqlCommand(); 
 548             bool mustCloseConnection = false; 
 549             PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
 550 
 551             // 创建SqlDataAdapter和DataSet. 
 552             using (SqlDataAdapter da = new SqlDataAdapter(cmd)) 
 553             { 
 554                 DataSet ds = new DataSet();
 555 
 556                 // 填充DataSet. 
 557                 da.Fill(ds);
 558 
 559                 cmd.Parameters.Clear();
 560 
 561                 if (mustCloseConnection) 
 562                     connection.Close();
 563 
 564                 return ds; 
 565             } 
 566         }
 567 
 568         /// 
 
 569         /// 执行指定数据库连接对象的命令,指定参数值,返回DataSet. 
 570         ///  
 571         ///  
 572         /// 此方法不提供访问存储过程输入参数和返回值. 
 573         /// 示例.:  
 574         ///  DataSet ds = ExecuteDataset(conn, "GetOrders", 24, 36); 
 575         ///  
 576         /// 一个有效的数据库连接对象 
 577         /// 存储过程名 
 578         /// 分配给存储过程输入参数的对象数组 
 579         /// 返回一个包含结果集的DataSet 
 580         public static DataSet ExecuteDataset(SqlConnection connection, string spName, params object[] parameterValues) 
 581         { 
 582             if (connection == null) throw new ArgumentNullException("connection"); 
 583             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
 584 
 585             if ((parameterValues != null) && (parameterValues.Length > 0)) 
 586             { 
 587                 // 比缓存中加载存储过程参数 
 588                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
 589 
 590                 // 给存储过程参数分配值 
 591                 AssignParameterValues(commandParameters, parameterValues);
 592 
 593                 return ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters); 
 594             } 
 595             else 
 596             { 
 597                 return ExecuteDataset(connection, CommandType.StoredProcedure, spName); 
 598             } 
 599         }
 600 
 601         /// 
 
 602         /// 执行指定事务的命令,返回DataSet. 
 603         ///  
 604         ///  
 605         /// 示例:  
 606         ///  DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders"); 
 607         ///  
 608         /// 事务 
 609         /// 命令类型 (存储过程,命令文本或其它) 
 610         /// 存储过程名或T-SQL语句 
 611         /// 返回一个包含结果集的DataSet 
 612         public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText) 
 613         { 
 614             return ExecuteDataset(transaction, commandType, commandText, (SqlParameter[])null); 
 615         }
 616 
 617         /// 
 
 618         /// 执行指定事务的命令,指定参数,返回DataSet. 
 619         ///  
 620         ///  
 621         /// 示例:  
 622         ///  DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 
 623         ///  
 624         /// 事务 
 625         /// 命令类型 (存储过程,命令文本或其它) 
 626         /// 存储过程名或T-SQL语句 
 627         /// SqlParamter参数数组 
 628         /// 返回一个包含结果集的DataSet 
 629         public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 
 630         { 
 631             if (transaction == null) throw new ArgumentNullException("transaction"); 
 632             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
 633 
 634             // 预处理 
 635             SqlCommand cmd = new SqlCommand(); 
 636             bool mustCloseConnection = false; 
 637             PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
 638 
 639             // 创建 DataAdapter & DataSet 
 640             using (SqlDataAdapter da = new SqlDataAdapter(cmd)) 
 641             { 
 642                 DataSet ds = new DataSet(); 
 643                 da.Fill(ds); 
 644                 cmd.Parameters.Clear(); 
 645                 return ds; 
 646             } 
 647         }
 648 
 649         /// 
 
 650         /// 执行指定事务的命令,指定参数值,返回DataSet. 
 651         ///  
 652         ///  
 653         /// 此方法不提供访问存储过程输入参数和返回值. 
 654         /// 示例.:  
 655         ///  DataSet ds = ExecuteDataset(trans, "GetOrders", 24, 36); 
 656         ///  
 657         /// 事务 
 658         /// 存储过程名 
 659         /// 分配给存储过程输入参数的对象数组 
 660         /// 返回一个包含结果集的DataSet 
 661         public static DataSet ExecuteDataset(SqlTransaction transaction, string spName, params object[] parameterValues) 
 662         { 
 663             if (transaction == null) throw new ArgumentNullException("transaction"); 
 664             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 
 665             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
 666 
 667             if ((parameterValues != null) && (parameterValues.Length > 0)) 
 668             { 
 669                 // 从缓存中加载存储过程参数 
 670                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
 671 
 672                 // 给存储过程参数分配值 
 673                 AssignParameterValues(commandParameters, parameterValues);
 674 
 675                 return ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters); 
 676             } 
 677             else 
 678             { 
 679                 return ExecuteDataset(transaction, CommandType.StoredProcedure, spName); 
 680             } 
 681         }
 682 
 683         #endregion ExecuteDataset数据集命令结束
 684 
 685         #region ExecuteReader 数据阅读器
 686 
 687         /// 
 
 688         /// 枚举,标识数据库连接是由SqlHelper提供还是由调用者提供 
 689         ///  
 690         private enum SqlConnectionOwnership 
 691         { 
 692             /// 
由SqlHelper提供连接 
 693             Internal, 
 694             /// 
由调用者提供连接 
 695             External 
 696         }
 697 
 698         /// 
 
 699         /// 执行指定数据库连接对象的数据阅读器. 
 700         ///  
 701         ///  
 702         /// 如果是SqlHelper打开连接,当连接关闭DataReader也将关闭. 
 703         /// 如果是调用都打开连接,DataReader由调用都管理. 
 704         ///  
 705         /// 一个有效的数据库连接对象 
 706         /// 一个有效的事务,或者为 'null' 
 707         /// 命令类型 (存储过程,命令文本或其它) 
 708         /// 存储过程名或T-SQL语句 
 709         /// SqlParameters参数数组,如果没有参数则为'null' 
 710         /// 标识数据库连接对象是由调用者提供还是由SqlHelper提供 
 711         /// 返回包含结果集的SqlDataReader 
 712         private static SqlDataReader ExecuteReader(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters, SqlConnectionOwnership connectionOwnership) 
 713         { 
 714             if (connection == null) throw new ArgumentNullException("connection");
 715 
 716             bool mustCloseConnection = false; 
 717             // 创建命令 
 718             SqlCommand cmd = new SqlCommand(); 
 719             try 
 720             { 
 721                 PrepareCommand(cmd, connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
 722 
 723                 // 创建数据阅读器 
 724                 SqlDataReader dataReader;
 725 
 726                 if (connectionOwnership == SqlConnectionOwnership.External) 
 727                 { 
 728                     dataReader = cmd.ExecuteReader(); 
 729                 } 
 730                 else 
 731                 { 
 732                     dataReader = cmd.ExecuteReader(CommandBehavior.CloseConnection); 
 733                 }
 734 
 735                 // 清除参数,以便再次使用.. 
 736                 // HACK: There is a problem here, the output parameter values are fletched 
 737                 // when the reader is closed, so if the parameters are detached from the command 
 738                 // then the SqlReader can磘 set its values. 
 739                 // When this happen, the parameters can磘 be used again in other command. 
 740                 bool canClear = true; 
 741                 foreach (SqlParameter commandParameter in cmd.Parameters) 
 742                 { 
 743                     if (commandParameter.Direction != ParameterDirection.Input) 
 744                         canClear = false; 
 745                 }
 746 
 747                 if (canClear) 
 748                 { 
 749                     cmd.Parameters.Clear(); 
 750                 }
 751 
 752                 return dataReader; 
 753             } 
 754             catch 
 755             { 
 756                 if (mustCloseConnection) 
 757                     connection.Close(); 
 758                 throw; 
 759             } 
 760         }
 761 
 762         /// 
 
 763         /// 执行指定数据库连接字符串的数据阅读器. 
 764         ///  
 765         ///  
 766         /// 示例:  
 767         ///  SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders"); 
 768         ///  
 769         /// 一个有效的数据库连接字符串 
 770         /// 命令类型 (存储过程,命令文本或其它) 
 771         /// 存储过程名或T-SQL语句 
 772         /// 返回包含结果集的SqlDataReader 
 773         public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText) 
 774         { 
 775             return ExecuteReader(connectionString, commandType, commandText, (SqlParameter[])null); 
 776         }
 777 
 778         /// 
 
 779         /// 执行指定数据库连接字符串的数据阅读器,指定参数. 
 780         ///  
 781         ///  
 782         /// 示例:  
 783         ///  SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 
 784         ///  
 785         /// 一个有效的数据库连接字符串 
 786         /// 命令类型 (存储过程,命令文本或其它) 
 787         /// 存储过程名或T-SQL语句 
 788         /// SqlParamter参数数组(new SqlParameter("@prodid", 24)) 
 789         /// 返回包含结果集的SqlDataReader 
 790         public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 
 791         { 
 792             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 
 793             SqlConnection connection = null; 
 794             try 
 795             { 
 796                 connection = new SqlConnection(connectionString); 
 797                 connection.Open();
 798 
 799                 return ExecuteReader(connection, null, commandType, commandText, commandParameters, SqlConnectionOwnership.Internal); 
 800             } 
 801             catch 
 802             { 
 803                 // If we fail to return the SqlDatReader, we need to close the connection ourselves 
 804                 if (connection != null) connection.Close(); 
 805                 throw; 
 806             }
 807 
 808         }
 809 
 810         /// 
 
 811         /// 执行指定数据库连接字符串的数据阅读器,指定参数值. 
 812         ///  
 813         ///  
 814         /// 此方法不提供访问存储过程输出参数和返回值参数. 
 815         /// 示例:  
 816         ///  SqlDataReader dr = ExecuteReader(connString, "GetOrders", 24, 36); 
 817         ///  
 818         /// 一个有效的数据库连接字符串 
 819         /// 存储过程名 
 820         /// 分配给存储过程输入参数的对象数组 
 821         /// 返回包含结果集的SqlDataReader 
 822         public static SqlDataReader ExecuteReader(string connectionString, string spName, params object[] parameterValues) 
 823         { 
 824             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 
 825             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
 826 
 827             if ((parameterValues != null) && (parameterValues.Length > 0)) 
 828             { 
 829                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
 830 
 831                 AssignParameterValues(commandParameters, parameterValues);
 832 
 833                 return ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters); 
 834             } 
 835             else 
 836             { 
 837                 return ExecuteReader(connectionString, CommandType.StoredProcedure, spName); 
 838             } 
 839         }
 840 
 841         /// 
 
 842         /// 执行指定数据库连接对象的数据阅读器. 
 843         ///  
 844         ///  
 845         /// 示例:  
 846         ///  SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders"); 
 847         ///  
 848         /// 一个有效的数据库连接对象 
 849         /// 命令类型 (存储过程,命令文本或其它) 
 850         /// 存储过程名或T-SQL语句 
 851         /// 返回包含结果集的SqlDataReader 
 852         public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText) 
 853         { 
 854             return ExecuteReader(connection, commandType, commandText, (SqlParameter[])null); 
 855         }
 856 
 857         /// 
 
 858         /// [调用者方式]执行指定数据库连接对象的数据阅读器,指定参数. 
 859         ///  
 860         ///  
 861         /// 示例:  
 862         ///  SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 
 863         ///  
 864         /// 一个有效的数据库连接对象 
 865         /// 命令类型 (存储过程,命令文本或其它) 
 866         /// 命令类型 (存储过程,命令文本或其它) 
 867         /// SqlParamter参数数组 
 868         /// 返回包含结果集的SqlDataReader 
 869         public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 
 870         { 
 871             return ExecuteReader(connection, (SqlTransaction)null, commandType, commandText, commandParameters, SqlConnectionOwnership.External); 
 872         }
 873 
 874         /// 
 
 875         /// [调用者方式]执行指定数据库连接对象的数据阅读器,指定参数值. 
 876         ///  
 877         ///  
 878         /// 此方法不提供访问存储过程输出参数和返回值参数. 
 879         /// 示例:  
 880         ///  SqlDataReader dr = ExecuteReader(conn, "GetOrders", 24, 36); 
 881         ///  
 882         /// 一个有效的数据库连接对象 
 883         /// T存储过程名 
 884         /// 分配给存储过程输入参数的对象数组 
 885         /// 返回包含结果集的SqlDataReader 
 886         public static SqlDataReader ExecuteReader(SqlConnection connection, string spName, params object[] parameterValues) 
 887         { 
 888             if (connection == null) throw new ArgumentNullException("connection"); 
 889             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
 890 
 891             if ((parameterValues != null) && (parameterValues.Length > 0)) 
 892             { 
 893                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
 894 
 895                 AssignParameterValues(commandParameters, parameterValues);
 896 
 897                 return ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters); 
 898             } 
 899             else 
 900             { 
 901                 return ExecuteReader(connection, CommandType.StoredProcedure, spName); 
 902             } 
 903         }
 904 
 905         /// 
 
 906         /// [调用者方式]执行指定数据库事务的数据阅读器,指定参数值. 
 907         ///  
 908         ///  
 909         /// 示例:  
 910         ///  SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders"); 
 911         ///  
 912         /// 一个有效的连接事务 
 913         /// 命令类型 (存储过程,命令文本或其它) 
 914         /// 存储过程名称或T-SQL语句 
 915         /// 返回包含结果集的SqlDataReader 
 916         public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText) 
 917         { 
 918             return ExecuteReader(transaction, commandType, commandText, (SqlParameter[])null); 
 919         }
 920 
 921         /// 
 
 922         /// [调用者方式]执行指定数据库事务的数据阅读器,指定参数. 
 923         ///  
 924         ///  
 925         /// 示例:  
 926         ///   SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 
 927         ///  
 928         /// 一个有效的连接事务 
 929         /// 命令类型 (存储过程,命令文本或其它) 
 930         /// 存储过程名称或T-SQL语句 
 931         /// 分配给命令的SqlParamter参数数组 
 932         /// 返回包含结果集的SqlDataReader 
 933         public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 
 934         { 
 935             if (transaction == null) throw new ArgumentNullException("transaction"); 
 936             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
 937 
 938             return ExecuteReader(transaction.Connection, transaction, commandType, commandText, commandParameters, SqlConnectionOwnership.External); 
 939         }
 940 
 941         /// 
 
 942         /// [调用者方式]执行指定数据库事务的数据阅读器,指定参数值. 
 943         ///  
 944         ///  
 945         /// 此方法不提供访问存储过程输出参数和返回值参数. 
 946         /// 
 947         /// 示例:  
 948         ///  SqlDataReader dr = ExecuteReader(trans, "GetOrders", 24, 36); 
 949         ///  
 950         /// 一个有效的连接事务 
 951         /// 存储过程名称 
 952         /// 分配给存储过程输入参数的对象数组 
 953         /// 返回包含结果集的SqlDataReader 
 954         public static SqlDataReader ExecuteReader(SqlTransaction transaction, string spName, params object[] parameterValues) 
 955         { 
 956             if (transaction == null) throw new ArgumentNullException("transaction"); 
 957             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 
 958             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
 959 
 960             // 如果有参数值 
 961             if ((parameterValues != null) && (parameterValues.Length > 0)) 
 962             { 
 963                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
 964 
 965                 AssignParameterValues(commandParameters, parameterValues);
 966 
 967                 return ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters); 
 968             } 
 969             else 
 970             { 
 971                 // 没有参数值 
 972                 return ExecuteReader(transaction, CommandType.StoredProcedure, spName); 
 973             } 
 974         }
 975 
 976         #endregion ExecuteReader数据阅读器
 977 
 978         #region ExecuteScalar 返回结果集中的第一行第一列
 979 
 980         /// 
 
 981         /// 执行指定数据库连接字符串的命令,返回结果集中的第一行第一列. 
 982         ///  
 983         ///  
 984         /// 示例:  
 985         ///  int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount"); 
 986         ///  
 987         /// 一个有效的数据库连接字符串 
 988         /// 命令类型 (存储过程,命令文本或其它) 
 989         /// 存储过程名称或T-SQL语句 
 990         /// 返回结果集中的第一行第一列 
 991         public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText) 
 992         { 
 993             // 执行参数为空的方法 
 994             return ExecuteScalar(connectionString, commandType, commandText, (SqlParameter[])null); 
 995         }
 996 
 997         /// 
 
 998         /// 执行指定数据库连接字符串的命令,指定参数,返回结果集中的第一行第一列. 
 999         ///  
1000         ///  
1001         /// 示例:  
1002         ///  int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24)); 
1003         ///  
1004         /// 一个有效的数据库连接字符串 
1005         /// 命令类型 (存储过程,命令文本或其它) 
1006         /// 存储过程名称或T-SQL语句 
1007         /// 分配给命令的SqlParamter参数数组 
1008         /// 返回结果集中的第一行第一列 
1009         public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 
1010         { 
1011             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 
1012             // 创建并打开数据库连接对象,操作完成释放对象. 
1013             using (SqlConnection connection = new SqlConnection(connectionString)) 
1014             { 
1015                 connection.Open();
1016 
1017                 // 调用指定数据库连接字符串重载方法. 
1018                 return ExecuteScalar(connection, commandType, commandText, commandParameters); 
1019             } 
1020         }
1021 
1022         /// 
 
1023         /// 执行指定数据库连接字符串的命令,指定参数值,返回结果集中的第一行第一列. 
1024         ///  
1025         ///  
1026         /// 此方法不提供访问存储过程输出参数和返回值参数. 
1027         /// 
1028         /// 示例:  
1029         ///  int orderCount = (int)ExecuteScalar(connString, "GetOrderCount", 24, 36); 
1030         ///  
1031         /// 一个有效的数据库连接字符串 
1032         /// 存储过程名称 
1033         /// 分配给存储过程输入参数的对象数组 
1034         /// 返回结果集中的第一行第一列 
1035         public static object ExecuteScalar(string connectionString, string spName, params object[] parameterValues) 
1036         { 
1037             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 
1038             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1039 
1040             // 如果有参数值 
1041             if ((parameterValues != null) && (parameterValues.Length > 0)) 
1042             { 
1043                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
1044                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
1045 
1046                 // 给存储过程参数赋值 
1047                 AssignParameterValues(commandParameters, parameterValues);
1048 
1049                 // 调用重载方法 
1050                 return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters); 
1051             } 
1052             else 
1053             { 
1054                 // 没有参数值 
1055                 return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName); 
1056             } 
1057         }
1058 
1059         /// 
 
1060         /// 执行指定数据库连接对象的命令,返回结果集中的第一行第一列. 
1061         ///  
1062         ///  
1063         /// 示例:  
1064         ///  int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount"); 
1065         ///  
1066         /// 一个有效的数据库连接对象 
1067         /// 命令类型 (存储过程,命令文本或其它) 
1068         /// 存储过程名称或T-SQL语句 
1069         /// 返回结果集中的第一行第一列 
1070         public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText) 
1071         { 
1072             // 执行参数为空的方法 
1073             return ExecuteScalar(connection, commandType, commandText, (SqlParameter[])null); 
1074         }
1075 
1076         /// 
 
1077         /// 执行指定数据库连接对象的命令,指定参数,返回结果集中的第一行第一列. 
1078         ///  
1079         ///  
1080         /// 示例:  
1081         ///  int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24)); 
1082         ///  
1083         /// 一个有效的数据库连接对象 
1084         /// 命令类型 (存储过程,命令文本或其它) 
1085         /// 存储过程名称或T-SQL语句 
1086         /// 分配给命令的SqlParamter参数数组 
1087         /// 返回结果集中的第一行第一列 
1088         public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 
1089         { 
1090             if (connection == null) throw new ArgumentNullException("connection");
1091 
1092             // 创建SqlCommand命令,并进行预处理 
1093             SqlCommand cmd = new SqlCommand();
1094 
1095             bool mustCloseConnection = false; 
1096             PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
1097 
1098             // 执行SqlCommand命令,并返回结果. 
1099             object retval = cmd.ExecuteScalar();
1100 
1101             // 清除参数,以便再次使用. 
1102             cmd.Parameters.Clear();
1103 
1104             if (mustCloseConnection) 
1105                 connection.Close();
1106 
1107             return retval; 
1108         }
1109 
1110         /// 
 
1111         /// 执行指定数据库连接对象的命令,指定参数值,返回结果集中的第一行第一列. 
1112         ///  
1113         ///  
1114         /// 此方法不提供访问存储过程输出参数和返回值参数. 
1115         /// 
1116         /// 示例:  
1117         ///  int orderCount = (int)ExecuteScalar(conn, "GetOrderCount", 24, 36); 
1118         ///  
1119         /// 一个有效的数据库连接对象 
1120         /// 存储过程名称 
1121         /// 分配给存储过程输入参数的对象数组 
1122         /// 返回结果集中的第一行第一列 
1123         public static object ExecuteScalar(SqlConnection connection, string spName, params object[] parameterValues) 
1124         { 
1125             if (connection == null) throw new ArgumentNullException("connection"); 
1126             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1127 
1128             // 如果有参数值 
1129             if ((parameterValues != null) && (parameterValues.Length > 0)) 
1130             { 
1131                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
1132                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1133 
1134                 // 给存储过程参数赋值 
1135                 AssignParameterValues(commandParameters, parameterValues);
1136 
1137                 // 调用重载方法 
1138                 return ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters); 
1139             } 
1140             else 
1141             { 
1142                 // 没有参数值 
1143                 return ExecuteScalar(connection, CommandType.StoredProcedure, spName); 
1144             } 
1145         }
1146 
1147         /// 
 
1148         /// 执行指定数据库事务的命令,返回结果集中的第一行第一列. 
1149         ///  
1150         ///  
1151         /// 示例:  
1152         ///  int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount"); 
1153         ///  
1154         /// 一个有效的连接事务 
1155         /// 命令类型 (存储过程,命令文本或其它) 
1156         /// 存储过程名称或T-SQL语句 
1157         /// 返回结果集中的第一行第一列 
1158         public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText) 
1159         { 
1160             // 执行参数为空的方法 
1161             return ExecuteScalar(transaction, commandType, commandText, (SqlParameter[])null); 
1162         }
1163 
1164         /// 
 
1165         /// 执行指定数据库事务的命令,指定参数,返回结果集中的第一行第一列. 
1166         ///  
1167         ///  
1168         /// 示例:  
1169         ///  int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24)); 
1170         ///  
1171         /// 一个有效的连接事务 
1172         /// 命令类型 (存储过程,命令文本或其它) 
1173         /// 存储过程名称或T-SQL语句 
1174         /// 分配给命令的SqlParamter参数数组 
1175         /// 返回结果集中的第一行第一列 
1176         public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 
1177         { 
1178             if (transaction == null) throw new ArgumentNullException("transaction"); 
1179             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
1180 
1181             // 创建SqlCommand命令,并进行预处理 
1182             SqlCommand cmd = new SqlCommand(); 
1183             bool mustCloseConnection = false; 
1184             PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
1185 
1186             // 执行SqlCommand命令,并返回结果. 
1187             object retval = cmd.ExecuteScalar();
1188 
1189             // 清除参数,以便再次使用. 
1190             cmd.Parameters.Clear(); 
1191             return retval; 
1192         }
1193 
1194         /// 
 
1195         /// 执行指定数据库事务的命令,指定参数值,返回结果集中的第一行第一列. 
1196         ///  
1197         ///  
1198         /// 此方法不提供访问存储过程输出参数和返回值参数. 
1199         /// 
1200         /// 示例:  
1201         ///  int orderCount = (int)ExecuteScalar(trans, "GetOrderCount", 24, 36); 
1202         ///  
1203         /// 一个有效的连接事务 
1204         /// 存储过程名称 
1205         /// 分配给存储过程输入参数的对象数组 
1206         /// 返回结果集中的第一行第一列 
1207         public static object ExecuteScalar(SqlTransaction transaction, string spName, params object[] parameterValues) 
1208         { 
1209             if (transaction == null) throw new ArgumentNullException("transaction"); 
1210             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 
1211             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1212 
1213             // 如果有参数值 
1214             if ((parameterValues != null) && (parameterValues.Length > 0)) 
1215             { 
1216                 // PPull the parameters for this stored procedure from the parameter cache () 
1217                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
1218 
1219                 // 给存储过程参数赋值 
1220                 AssignParameterValues(commandParameters, parameterValues);
1221 
1222                 // 调用重载方法 
1223                 return ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters); 
1224             } 
1225             else 
1226             { 
1227                 // 没有参数值 
1228                 return ExecuteScalar(transaction, CommandType.StoredProcedure, spName); 
1229             } 
1230         }
1231 
1232         #endregion ExecuteScalar
1233 
1234         #region ExecuteXmlReader XML阅读器 
1235         /// 
 
1236         /// 执行指定数据库连接对象的SqlCommand命令,并产生一个XmlReader对象做为结果集返回. 
1237         ///  
1238         ///  
1239         /// 示例:  
1240         ///  XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders"); 
1241         ///  
1242         /// 一个有效的数据库连接对象 
1243         /// 命令类型 (存储过程,命令文本或其它) 
1244         /// 存储过程名称或T-SQL语句 using "FOR XML AUTO" 
1245         /// 返回XmlReader结果集对象. 
1246         public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText) 
1247         { 
1248             // 执行参数为空的方法 
1249             return ExecuteXmlReader(connection, commandType, commandText, (SqlParameter[])null); 
1250         }
1251 
1252         /// 
 
1253         /// 执行指定数据库连接对象的SqlCommand命令,并产生一个XmlReader对象做为结果集返回,指定参数. 
1254         ///  
1255         ///  
1256         /// 示例:  
1257         ///  XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 
1258         ///  
1259         /// 一个有效的数据库连接对象 
1260         /// 命令类型 (存储过程,命令文本或其它) 
1261         /// 存储过程名称或T-SQL语句 using "FOR XML AUTO" 
1262         /// 分配给命令的SqlParamter参数数组 
1263         /// 返回XmlReader结果集对象. 
1264         public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 
1265         { 
1266             if (connection == null) throw new ArgumentNullException("connection");
1267 
1268             bool mustCloseConnection = false; 
1269             // 创建SqlCommand命令,并进行预处理 
1270             SqlCommand cmd = new SqlCommand(); 
1271             try 
1272             { 
1273                 PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
1274 
1275                 // 执行命令 
1276                 XmlReader retval = cmd.ExecuteXmlReader();
1277 
1278                 // 清除参数,以便再次使用. 
1279                 cmd.Parameters.Clear();
1280 
1281                 return retval; 
1282             } 
1283             catch 
1284             { 
1285                 if (mustCloseConnection) 
1286                     connection.Close(); 
1287                 throw; 
1288             } 
1289         }
1290 
1291         /// 
 
1292         /// 执行指定数据库连接对象的SqlCommand命令,并产生一个XmlReader对象做为结果集返回,指定参数值. 
1293         ///  
1294         ///  
1295         /// 此方法不提供访问存储过程输出参数和返回值参数. 
1296         /// 
1297         /// 示例:  
1298         ///  XmlReader r = ExecuteXmlReader(conn, "GetOrders", 24, 36); 
1299         ///  
1300         /// 一个有效的数据库连接对象 
1301         /// 存储过程名称 using "FOR XML AUTO" 
1302         /// 分配给存储过程输入参数的对象数组 
1303         /// 返回XmlReader结果集对象. 
1304         public static XmlReader ExecuteXmlReader(SqlConnection connection, string spName, params object[] parameterValues) 
1305         { 
1306             if (connection == null) throw new ArgumentNullException("connection"); 
1307             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1308 
1309             // 如果有参数值 
1310             if ((parameterValues != null) && (parameterValues.Length > 0)) 
1311             { 
1312                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
1313                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1314 
1315                 // 给存储过程参数赋值 
1316                 AssignParameterValues(commandParameters, parameterValues);
1317 
1318                 // 调用重载方法 
1319                 return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters); 
1320             } 
1321             else 
1322             { 
1323                 // 没有参数值 
1324                 return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName); 
1325             } 
1326         }
1327 
1328         /// 
 
1329         /// 执行指定数据库事务的SqlCommand命令,并产生一个XmlReader对象做为结果集返回. 
1330         ///  
1331         ///  
1332         /// 示例:  
1333         ///  XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders"); 
1334         ///  
1335         /// 一个有效的连接事务 
1336         /// 命令类型 (存储过程,命令文本或其它) 
1337         /// 存储过程名称或T-SQL语句 using "FOR XML AUTO" 
1338         /// 返回XmlReader结果集对象. 
1339         public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText) 
1340         { 
1341             // 执行参数为空的方法 
1342             return ExecuteXmlReader(transaction, commandType, commandText, (SqlParameter[])null); 
1343         }
1344 
1345         /// 
 
1346         /// 执行指定数据库事务的SqlCommand命令,并产生一个XmlReader对象做为结果集返回,指定参数. 
1347         ///  
1348         ///  
1349         /// 示例:  
1350         ///  XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); 
1351         ///  
1352         /// 一个有效的连接事务 
1353         /// 命令类型 (存储过程,命令文本或其它) 
1354         /// 存储过程名称或T-SQL语句 using "FOR XML AUTO" 
1355         /// 分配给命令的SqlParamter参数数组 
1356         /// 返回XmlReader结果集对象. 
1357         public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters) 
1358         { 
1359             if (transaction == null) throw new ArgumentNullException("transaction"); 
1360             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
1361 
1362             // 创建SqlCommand命令,并进行预处理 
1363             SqlCommand cmd = new SqlCommand(); 
1364             bool mustCloseConnection = false; 
1365             PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
1366 
1367             // 执行命令 
1368             XmlReader retval = cmd.ExecuteXmlReader();
1369 
1370             // 清除参数,以便再次使用. 
1371             cmd.Parameters.Clear(); 
1372             return retval; 
1373         }
1374 
1375         /// 
 
1376         /// 执行指定数据库事务的SqlCommand命令,并产生一个XmlReader对象做为结果集返回,指定参数值. 
1377         ///  
1378         ///  
1379         /// 此方法不提供访问存储过程输出参数和返回值参数. 
1380         /// 
1381         /// 示例:  
1382         ///  XmlReader r = ExecuteXmlReader(trans, "GetOrders", 24, 36); 
1383         ///  
1384         /// 一个有效的连接事务 
1385         /// 存储过程名称 
1386         /// 分配给存储过程输入参数的对象数组 
1387         /// 返回一个包含结果集的DataSet. 
1388         public static XmlReader ExecuteXmlReader(SqlTransaction transaction, string spName, params object[] parameterValues) 
1389         { 
1390             if (transaction == null) throw new ArgumentNullException("transaction"); 
1391             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 
1392             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1393 
1394             // 如果有参数值 
1395             if ((parameterValues != null) && (parameterValues.Length > 0)) 
1396             { 
1397                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
1398                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
1399 
1400                 // 给存储过程参数赋值 
1401                 AssignParameterValues(commandParameters, parameterValues);
1402 
1403                 // 调用重载方法 
1404                 return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName, commandParameters); 
1405             } 
1406             else 
1407             { 
1408                 // 没有参数值 
1409                 return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName); 
1410             } 
1411         }
1412 
1413         #endregion ExecuteXmlReader 阅读器结束
1414 
1415         #region FillDataset 填充数据集 
1416         /// 
 
1417         /// 执行指定数据库连接字符串的命令,映射数据表并填充数据集. 
1418         ///  
1419         ///  
1420         /// 示例:  
1421         ///  FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}); 
1422         ///  
1423         /// 一个有效的数据库连接字符串 
1424         /// 命令类型 (存储过程,命令文本或其它) 
1425         /// 存储过程名称或T-SQL语句 
1426         /// 要填充结果集的DataSet实例 
1427         /// 表映射的数据表数组 
1428         /// 用户定义的表名 (可有是实际的表名.) 
1429         public static void FillDataset(string connectionString, CommandType commandType, string commandText, DataSet dataSet, string[] tableNames) 
1430         { 
1431             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 
1432             if (dataSet == null) throw new ArgumentNullException("dataSet");
1433 
1434             // 创建并打开数据库连接对象,操作完成释放对象. 
1435             using (SqlConnection connection = new SqlConnection(connectionString)) 
1436             { 
1437                 connection.Open();
1438 
1439                 // 调用指定数据库连接字符串重载方法. 
1440                 FillDataset(connection, commandType, commandText, dataSet, tableNames); 
1441             } 
1442         }
1443 
1444         /// 
 
1445         /// 执行指定数据库连接字符串的命令,映射数据表并填充数据集.指定命令参数. 
1446         ///  
1447         ///  
1448         /// 示例:  
1449         ///  FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24)); 
1450         ///  
1451         /// 一个有效的数据库连接字符串 
1452         /// 命令类型 (存储过程,命令文本或其它) 
1453         /// 存储过程名称或T-SQL语句 
1454         /// 分配给命令的SqlParamter参数数组 
1455         /// 要填充结果集的DataSet实例 
1456         /// 表映射的数据表数组 
1457         /// 用户定义的表名 (可有是实际的表名.) 
1458         ///  
1459         public static void FillDataset(string connectionString, CommandType commandType, 
1460             string commandText, DataSet dataSet, string[] tableNames, 
1461             params SqlParameter[] commandParameters) 
1462         { 
1463             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 
1464             if (dataSet == null) throw new ArgumentNullException("dataSet"); 
1465             // 创建并打开数据库连接对象,操作完成释放对象. 
1466             using (SqlConnection connection = new SqlConnection(connectionString)) 
1467             { 
1468                 connection.Open();
1469 
1470                 // 调用指定数据库连接字符串重载方法. 
1471                 FillDataset(connection, commandType, commandText, dataSet, tableNames, commandParameters); 
1472             } 
1473         }
1474 
1475         /// 
 
1476         /// 执行指定数据库连接字符串的命令,映射数据表并填充数据集,指定存储过程参数值. 
1477         ///  
1478         ///  
1479         /// 此方法不提供访问存储过程输出参数和返回值参数. 
1480         /// 
1481         /// 示例:  
1482         ///  FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, 24); 
1483         ///  
1484         /// 一个有效的数据库连接字符串 
1485         /// 存储过程名称 
1486         /// 要填充结果集的DataSet实例 
1487         /// 表映射的数据表数组 
1488         /// 用户定义的表名 (可有是实际的表名.) 
1489         ///     
1490         /// 分配给存储过程输入参数的对象数组 
1491         public static void FillDataset(string connectionString, string spName, 
1492             DataSet dataSet, string[] tableNames, 
1493             params object[] parameterValues) 
1494         { 
1495             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 
1496             if (dataSet == null) throw new ArgumentNullException("dataSet"); 
1497             // 创建并打开数据库连接对象,操作完成释放对象. 
1498             using (SqlConnection connection = new SqlConnection(connectionString)) 
1499             { 
1500                 connection.Open();
1501 
1502                 // 调用指定数据库连接字符串重载方法. 
1503                 FillDataset(connection, spName, dataSet, tableNames, parameterValues); 
1504             } 
1505         }
1506 
1507         /// 
 
1508         /// 执行指定数据库连接对象的命令,映射数据表并填充数据集. 
1509         ///  
1510         ///  
1511         /// 示例:  
1512         ///  FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}); 
1513         ///  
1514         /// 一个有效的数据库连接对象 
1515         /// 命令类型 (存储过程,命令文本或其它) 
1516         /// 存储过程名称或T-SQL语句 
1517         /// 要填充结果集的DataSet实例 
1518         /// 表映射的数据表数组 
1519         /// 用户定义的表名 (可有是实际的表名.) 
1520         ///     
1521         public static void FillDataset(SqlConnection connection, CommandType commandType, 
1522             string commandText, DataSet dataSet, string[] tableNames) 
1523         { 
1524             FillDataset(connection, commandType, commandText, dataSet, tableNames, null); 
1525         }
1526 
1527         /// 
 
1528         /// 执行指定数据库连接对象的命令,映射数据表并填充数据集,指定参数. 
1529         ///  
1530         ///  
1531         /// 示例:  
1532         ///  FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24)); 
1533         ///  
1534         /// 一个有效的数据库连接对象 
1535         /// 命令类型 (存储过程,命令文本或其它) 
1536         /// 存储过程名称或T-SQL语句 
1537         /// 要填充结果集的DataSet实例 
1538         /// 表映射的数据表数组 
1539         /// 用户定义的表名 (可有是实际的表名.) 
1540         ///  
1541         /// 分配给命令的SqlParamter参数数组 
1542         public static void FillDataset(SqlConnection connection, CommandType commandType, 
1543             string commandText, DataSet dataSet, string[] tableNames, 
1544             params SqlParameter[] commandParameters) 
1545         { 
1546             FillDataset(connection, null, commandType, commandText, dataSet, tableNames, commandParameters); 
1547         }
1548 
1549         /// 
 
1550         /// 执行指定数据库连接对象的命令,映射数据表并填充数据集,指定存储过程参数值. 
1551         ///  
1552         ///  
1553         /// 此方法不提供访问存储过程输出参数和返回值参数. 
1554         /// 
1555         /// 示例:  
1556         ///  FillDataset(conn, "GetOrders", ds, new string[] {"orders"}, 24, 36); 
1557         ///  
1558         /// 一个有效的数据库连接对象 
1559         /// 存储过程名称 
1560         /// 要填充结果集的DataSet实例 
1561         /// 表映射的数据表数组 
1562         /// 用户定义的表名 (可有是实际的表名.) 
1563         ///  
1564         /// 分配给存储过程输入参数的对象数组 
1565         public static void FillDataset(SqlConnection connection, string spName, 
1566             DataSet dataSet, string[] tableNames, 
1567             params object[] parameterValues) 
1568         { 
1569             if (connection == null) throw new ArgumentNullException("connection"); 
1570             if (dataSet == null) throw new ArgumentNullException("dataSet"); 
1571             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1572 
1573             // 如果有参数值 
1574             if ((parameterValues != null) && (parameterValues.Length > 0)) 
1575             { 
1576                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
1577                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1578 
1579                 // 给存储过程参数赋值 
1580                 AssignParameterValues(commandParameters, parameterValues);
1581 
1582                 // 调用重载方法 
1583                 FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames, commandParameters); 
1584             } 
1585             else 
1586             { 
1587                 // 没有参数值 
1588                 FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames); 
1589             } 
1590         }
1591 
1592         /// 
 
1593         /// 执行指定数据库事务的命令,映射数据表并填充数据集. 
1594         ///  
1595         ///  
1596         /// 示例:  
1597         ///  FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}); 
1598         ///  
1599         /// 一个有效的连接事务 
1600         /// 命令类型 (存储过程,命令文本或其它) 
1601         /// 存储过程名称或T-SQL语句 
1602         /// 要填充结果集的DataSet实例 
1603         /// 表映射的数据表数组 
1604         /// 用户定义的表名 (可有是实际的表名.) 
1605         ///  
1606         public static void FillDataset(SqlTransaction transaction, CommandType commandType, 
1607             string commandText, 
1608             DataSet dataSet, string[] tableNames) 
1609         { 
1610             FillDataset(transaction, commandType, commandText, dataSet, tableNames, null); 
1611         }
1612 
1613         /// 
 
1614         /// 执行指定数据库事务的命令,映射数据表并填充数据集,指定参数. 
1615         ///  
1616         ///  
1617         /// 示例:  
1618         ///  FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24)); 
1619         ///  
1620         /// 一个有效的连接事务 
1621         /// 命令类型 (存储过程,命令文本或其它) 
1622         /// 存储过程名称或T-SQL语句 
1623         /// 要填充结果集的DataSet实例 
1624         /// 表映射的数据表数组 
1625         /// 用户定义的表名 (可有是实际的表名.) 
1626         ///  
1627         /// 分配给命令的SqlParamter参数数组 
1628         public static void FillDataset(SqlTransaction transaction, CommandType commandType, 
1629             string commandText, DataSet dataSet, string[] tableNames, 
1630             params SqlParameter[] commandParameters) 
1631         { 
1632             FillDataset(transaction.Connection, transaction, commandType, commandText, dataSet, tableNames, commandParameters); 
1633         }
1634 
1635         /// 
 
1636         /// 执行指定数据库事务的命令,映射数据表并填充数据集,指定存储过程参数值. 
1637         ///  
1638         ///  
1639         /// 此方法不提供访问存储过程输出参数和返回值参数. 
1640         /// 
1641         /// 示例:  
1642         ///  FillDataset(trans, "GetOrders", ds, new string[]{"orders"}, 24, 36); 
1643         ///  
1644         /// 一个有效的连接事务 
1645         /// 存储过程名称 
1646         /// 要填充结果集的DataSet实例 
1647         /// 表映射的数据表数组 
1648         /// 用户定义的表名 (可有是实际的表名.) 
1649         ///  
1650         /// 分配给存储过程输入参数的对象数组 
1651         public static void FillDataset(SqlTransaction transaction, string spName, 
1652             DataSet dataSet, string[] tableNames, 
1653             params object[] parameterValues) 
1654         { 
1655             if (transaction == null) throw new ArgumentNullException("transaction"); 
1656             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 
1657             if (dataSet == null) throw new ArgumentNullException("dataSet"); 
1658             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1659 
1660             // 如果有参数值 
1661             if ((parameterValues != null) && (parameterValues.Length > 0)) 
1662             { 
1663                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
1664                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
1665 
1666                 // 给存储过程参数赋值 
1667                 AssignParameterValues(commandParameters, parameterValues);
1668 
1669                 // 调用重载方法 
1670                 FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames, commandParameters); 
1671             } 
1672             else 
1673             { 
1674                 // 没有参数值 
1675                 FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames); 
1676             } 
1677         }
1678 
1679         /// 
 
1680         /// [私有方法][内部调用]执行指定数据库连接对象/事务的命令,映射数据表并填充数据集,DataSet/TableNames/SqlParameters. 
1681         ///  
1682         ///  
1683         /// 示例:  
1684         ///  FillDataset(conn, trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24)); 
1685         ///  
1686         /// 一个有效的数据库连接对象 
1687         /// 一个有效的连接事务 
1688         /// 命令类型 (存储过程,命令文本或其它) 
1689         /// 存储过程名称或T-SQL语句 
1690         /// 要填充结果集的DataSet实例 
1691         /// 表映射的数据表数组 
1692         /// 用户定义的表名 (可有是实际的表名.) 
1693         ///  
1694         /// 分配给命令的SqlParamter参数数组 
1695         private static void FillDataset(SqlConnection connection, SqlTransaction transaction, CommandType commandType, 
1696             string commandText, DataSet dataSet, string[] tableNames, 
1697             params SqlParameter[] commandParameters) 
1698         { 
1699             if (connection == null) throw new ArgumentNullException("connection"); 
1700             if (dataSet == null) throw new ArgumentNullException("dataSet");
1701 
1702             // 创建SqlCommand命令,并进行预处理 
1703             SqlCommand command = new SqlCommand(); 
1704             bool mustCloseConnection = false; 
1705             PrepareCommand(command, connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
1706 
1707             // 执行命令 
1708             using (SqlDataAdapter dataAdapter = new SqlDataAdapter(command)) 
1709             {
1710 
1711                 // 追加表映射 
1712                 if (tableNames != null && tableNames.Length > 0) 
1713                 { 
1714                     string tableName = "Table"; 
1715                     for (int index = 0; index < tableNames.Length; index++) 
1716                     { 
1717                         if (tableNames[index] == null || tableNames[index].Length == 0) throw new ArgumentException("The tableNames parameter must contain a list of tables, a value was provided as null or empty string.", "tableNames"); 
1718                         dataAdapter.TableMappings.Add(tableName, tableNames[index]); 
1719                         tableName += (index + 1).ToString(); 
1720                     } 
1721                 }
1722 
1723                 // 填充数据集使用默认表名称 
1724                 dataAdapter.Fill(dataSet);
1725 
1726                 // 清除参数,以便再次使用. 
1727                 command.Parameters.Clear(); 
1728             }
1729 
1730             if (mustCloseConnection) 
1731                 connection.Close(); 
1732         } 
1733         #endregion
1734 
1735         #region UpdateDataset 更新数据集 
1736         /// 
 
1737         /// 执行数据集更新到数据库,指定inserted, updated, or deleted命令. 
1738         ///  
1739         ///  
1740         /// 示例:  
1741         ///  UpdateDataset(conn, insertCommand, deleteCommand, updateCommand, dataSet, "Order"); 
1742         ///  
1743         /// [追加记录]一个有效的T-SQL语句或存储过程 
1744         /// [删除记录]一个有效的T-SQL语句或存储过程 
1745         /// [更新记录]一个有效的T-SQL语句或存储过程 
1746         /// 要更新到数据库的DataSet 
1747         /// 要更新到数据库的DataTable 
1748         public static void UpdateDataset(SqlCommand insertCommand, SqlCommand deleteCommand, SqlCommand updateCommand, DataSet dataSet, string tableName) 
1749         { 
1750             if (insertCommand == null) throw new ArgumentNullException("insertCommand"); 
1751             if (deleteCommand == null) throw new ArgumentNullException("deleteCommand"); 
1752             if (updateCommand == null) throw new ArgumentNullException("updateCommand"); 
1753             if (tableName == null || tableName.Length == 0) throw new ArgumentNullException("tableName");
1754 
1755             // 创建SqlDataAdapter,当操作完成后释放. 
1756             using (SqlDataAdapter dataAdapter = new SqlDataAdapter()) 
1757             { 
1758                 // 设置数据适配器命令 
1759                 dataAdapter.UpdateCommand = updateCommand; 
1760                 dataAdapter.InsertCommand = insertCommand; 
1761                 dataAdapter.DeleteCommand = deleteCommand;
1762 
1763                 // 更新数据集改变到数据库 
1764                 dataAdapter.Update(dataSet, tableName);
1765 
1766                 // 提交所有改变到数据集. 
1767                 dataSet.AcceptChanges(); 
1768             } 
1769         } 
1770         #endregion
1771 
1772         #region CreateCommand 创建一条SqlCommand命令 
1773         /// 
 
1774         /// 创建SqlCommand命令,指定数据库连接对象,存储过程名和参数. 
1775         ///  
1776         ///  
1777         /// 示例:  
1778         ///  SqlCommand command = CreateCommand(conn, "AddCustomer", "CustomerID", "CustomerName"); 
1779         ///  
1780         /// 一个有效的数据库连接对象 
1781         /// 存储过程名称 
1782         /// 源表的列名称数组 
1783         /// 返回SqlCommand命令 
1784         public static SqlCommand CreateCommand(SqlConnection connection, string spName, params string[] sourceColumns) 
1785         { 
1786             if (connection == null) throw new ArgumentNullException("connection"); 
1787             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1788 
1789             // 创建命令 
1790             SqlCommand cmd = new SqlCommand(spName, connection); 
1791             cmd.CommandType = CommandType.StoredProcedure;
1792 
1793             // 如果有参数值 
1794             if ((sourceColumns != null) && (sourceColumns.Length > 0)) 
1795             { 
1796                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
1797                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1798 
1799                 // 将源表的列到映射到DataSet命令中. 
1800                 for (int index = 0; index < sourceColumns.Length; index++) 
1801                     commandParameters[index].SourceColumn = sourceColumns[index];
1802 
1803                 // Attach the discovered parameters to the SqlCommand object 
1804                 AttachParameters(cmd, commandParameters); 
1805             }
1806 
1807             return cmd; 
1808         } 
1809         #endregion
1810 
1811         #region ExecuteNonQueryTypedParams 类型化参数(DataRow) 
1812         /// 
 
1813         /// 执行指定连接数据库连接字符串的存储过程,使用DataRow做为参数值,返回受影响的行数. 
1814         ///  
1815         /// 一个有效的数据库连接字符串 
1816         /// 存储过程名称 
1817         /// 使用DataRow作为参数值 
1818         /// 返回影响的行数 
1819         public static int ExecuteNonQueryTypedParams(String connectionString, String spName, DataRow dataRow) 
1820         { 
1821             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 
1822             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1823 
1824             // 如果row有值,存储过程必须初始化. 
1825             if (dataRow != null && dataRow.ItemArray.Length > 0) 
1826             { 
1827                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
1828                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
1829 
1830                 // 分配参数值 
1831                 AssignParameterValues(commandParameters, dataRow);
1832 
1833                 return SqlHelper.ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters); 
1834             } 
1835             else 
1836             { 
1837                 return SqlHelper.ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName); 
1838             } 
1839         }
1840 
1841         /// 
 
1842         /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回受影响的行数. 
1843         ///  
1844         /// 一个有效的数据库连接对象 
1845         /// 存储过程名称 
1846         /// 使用DataRow作为参数值 
1847         /// 返回影响的行数 
1848         public static int ExecuteNonQueryTypedParams(SqlConnection connection, String spName, DataRow dataRow) 
1849         { 
1850             if (connection == null) throw new ArgumentNullException("connection"); 
1851             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1852 
1853             // 如果row有值,存储过程必须初始化. 
1854             if (dataRow != null && dataRow.ItemArray.Length > 0) 
1855             { 
1856                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
1857                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1858 
1859                 // 分配参数值 
1860                 AssignParameterValues(commandParameters, dataRow);
1861 
1862                 return SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters); 
1863             } 
1864             else 
1865             { 
1866                 return SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, spName); 
1867             } 
1868         }
1869 
1870         /// 
 
1871         /// 执行指定连接数据库事物的存储过程,使用DataRow做为参数值,返回受影响的行数. 
1872         ///  
1873         /// 一个有效的连接事务 object 
1874         /// 存储过程名称 
1875         /// 使用DataRow作为参数值 
1876         /// 返回影响的行数 
1877         public static int ExecuteNonQueryTypedParams(SqlTransaction transaction, String spName, DataRow dataRow) 
1878         { 
1879             if (transaction == null) throw new ArgumentNullException("transaction"); 
1880             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 
1881             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1882 
1883             // Sf the row has values, the store procedure parameters must be initialized 
1884             if (dataRow != null && dataRow.ItemArray.Length > 0) 
1885             { 
1886                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
1887                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
1888 
1889                 // 分配参数值 
1890                 AssignParameterValues(commandParameters, dataRow);
1891 
1892                 return SqlHelper.ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters); 
1893             } 
1894             else 
1895             { 
1896                 return SqlHelper.ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName); 
1897             } 
1898         } 
1899         #endregion
1900 
1901         #region ExecuteDatasetTypedParams 类型化参数(DataRow) 
1902         /// 
 
1903         /// 执行指定连接数据库连接字符串的存储过程,使用DataRow做为参数值,返回DataSet. 
1904         ///  
1905         /// 一个有效的数据库连接字符串 
1906         /// 存储过程名称 
1907         /// 使用DataRow作为参数值 
1908         /// 返回一个包含结果集的DataSet. 
1909         public static DataSet ExecuteDatasetTypedParams(string connectionString, String spName, DataRow dataRow) 
1910         { 
1911             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 
1912             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1913 
1914             //如果row有值,存储过程必须初始化. 
1915             if (dataRow != null && dataRow.ItemArray.Length > 0) 
1916             { 
1917                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
1918                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
1919 
1920                 // 分配参数值 
1921                 AssignParameterValues(commandParameters, dataRow);
1922 
1923                 return SqlHelper.ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters); 
1924             } 
1925             else 
1926             { 
1927                 return SqlHelper.ExecuteDataset(connectionString, CommandType.StoredProcedure, spName); 
1928             } 
1929         }
1930 
1931         /// 
 
1932         /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回DataSet. 
1933         ///  
1934         /// 一个有效的数据库连接对象 
1935         /// 存储过程名称 
1936         /// 使用DataRow作为参数值 
1937         /// 返回一个包含结果集的DataSet. 
1938         /// 
1939         public static DataSet ExecuteDatasetTypedParams(SqlConnection connection, String spName, DataRow dataRow) 
1940         { 
1941             if (connection == null) throw new ArgumentNullException("connection"); 
1942             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1943 
1944             // 如果row有值,存储过程必须初始化. 
1945             if (dataRow != null && dataRow.ItemArray.Length > 0) 
1946             { 
1947                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
1948                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1949 
1950                 // 分配参数值 
1951                 AssignParameterValues(commandParameters, dataRow);
1952 
1953                 return SqlHelper.ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters); 
1954             } 
1955             else 
1956             { 
1957                 return SqlHelper.ExecuteDataset(connection, CommandType.StoredProcedure, spName); 
1958             } 
1959         }
1960 
1961         /// 
 
1962         /// 执行指定连接数据库事务的存储过程,使用DataRow做为参数值,返回DataSet. 
1963         ///  
1964         /// 一个有效的连接事务 object 
1965         /// 存储过程名称 
1966         /// 使用DataRow作为参数值 
1967         /// 返回一个包含结果集的DataSet. 
1968         public static DataSet ExecuteDatasetTypedParams(SqlTransaction transaction, String spName, DataRow dataRow) 
1969         { 
1970             if (transaction == null) throw new ArgumentNullException("transaction"); 
1971             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 
1972             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1973 
1974             // 如果row有值,存储过程必须初始化. 
1975             if (dataRow != null && dataRow.ItemArray.Length > 0) 
1976             { 
1977                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
1978                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
1979 
1980                 // 分配参数值 
1981                 AssignParameterValues(commandParameters, dataRow);
1982 
1983                 return SqlHelper.ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters); 
1984             } 
1985             else 
1986             { 
1987                 return SqlHelper.ExecuteDataset(transaction, CommandType.StoredProcedure, spName); 
1988             } 
1989         }
1990 
1991         #endregion
1992 
1993         #region ExecuteReaderTypedParams 类型化参数(DataRow) 
1994         /// 
 
1995         /// 执行指定连接数据库连接字符串的存储过程,使用DataRow做为参数值,返回DataReader. 
1996         ///  
1997         /// 一个有效的数据库连接字符串 
1998         /// 存储过程名称 
1999         /// 使用DataRow作为参数值 
2000         /// 返回包含结果集的SqlDataReader 
2001         public static SqlDataReader ExecuteReaderTypedParams(String connectionString, String spName, DataRow dataRow) 
2002         { 
2003             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 
2004             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2005 
2006             // 如果row有值,存储过程必须初始化. 
2007             if (dataRow != null && dataRow.ItemArray.Length > 0) 
2008             { 
2009                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
2010                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
2011 
2012                 // 分配参数值 
2013                 AssignParameterValues(commandParameters, dataRow);
2014 
2015                 return SqlHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters); 
2016             } 
2017             else 
2018             { 
2019                 return SqlHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, spName); 
2020             } 
2021         }
2022 
2023 
2024         /// 
 
2025         /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回DataReader. 
2026         ///  
2027         /// 一个有效的数据库连接对象 
2028         /// 存储过程名称 
2029         /// 使用DataRow作为参数值 
2030         /// 返回包含结果集的SqlDataReader 
2031         public static SqlDataReader ExecuteReaderTypedParams(SqlConnection connection, String spName, DataRow dataRow) 
2032         { 
2033             if (connection == null) throw new ArgumentNullException("connection"); 
2034             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2035 
2036             // 如果row有值,存储过程必须初始化. 
2037             if (dataRow != null && dataRow.ItemArray.Length > 0) 
2038             { 
2039                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
2040                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
2041 
2042                 // 分配参数值 
2043                 AssignParameterValues(commandParameters, dataRow);
2044 
2045                 return SqlHelper.ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters); 
2046             } 
2047             else 
2048             { 
2049                 return SqlHelper.ExecuteReader(connection, CommandType.StoredProcedure, spName); 
2050             } 
2051         }
2052 
2053         /// 
 
2054         /// 执行指定连接数据库事物的存储过程,使用DataRow做为参数值,返回DataReader. 
2055         ///  
2056         /// 一个有效的连接事务 object 
2057         /// 存储过程名称 
2058         /// 使用DataRow作为参数值 
2059         /// 返回包含结果集的SqlDataReader 
2060         public static SqlDataReader ExecuteReaderTypedParams(SqlTransaction transaction, String spName, DataRow dataRow) 
2061         { 
2062             if (transaction == null) throw new ArgumentNullException("transaction"); 
2063             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 
2064             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2065 
2066             // 如果row有值,存储过程必须初始化. 
2067             if (dataRow != null && dataRow.ItemArray.Length > 0) 
2068             { 
2069                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
2070                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
2071 
2072                 // 分配参数值 
2073                 AssignParameterValues(commandParameters, dataRow);
2074 
2075                 return SqlHelper.ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters); 
2076             } 
2077             else 
2078             { 
2079                 return SqlHelper.ExecuteReader(transaction, CommandType.StoredProcedure, spName); 
2080             } 
2081         } 
2082         #endregion
2083 
2084         #region ExecuteScalarTypedParams 类型化参数(DataRow) 
2085         /// 
 
2086         /// 执行指定连接数据库连接字符串的存储过程,使用DataRow做为参数值,返回结果集中的第一行第一列. 
2087         ///  
2088         /// 一个有效的数据库连接字符串 
2089         /// 存储过程名称 
2090         /// 使用DataRow作为参数值 
2091         /// 返回结果集中的第一行第一列 
2092         public static object ExecuteScalarTypedParams(String connectionString, String spName, DataRow dataRow) 
2093         { 
2094             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 
2095             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2096 
2097             // 如果row有值,存储过程必须初始化. 
2098             if (dataRow != null && dataRow.ItemArray.Length > 0) 
2099             { 
2100                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
2101                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
2102 
2103                 // 分配参数值 
2104                 AssignParameterValues(commandParameters, dataRow);
2105 
2106                 return SqlHelper.ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters); 
2107             } 
2108             else 
2109             { 
2110                 return SqlHelper.ExecuteScalar(connectionString, CommandType.StoredProcedure, spName); 
2111             } 
2112         }
2113 
2114         /// 
 
2115         /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回结果集中的第一行第一列. 
2116         ///  
2117         /// 一个有效的数据库连接对象 
2118         /// 存储过程名称 
2119         /// 使用DataRow作为参数值 
2120         /// 返回结果集中的第一行第一列 
2121         public static object ExecuteScalarTypedParams(SqlConnection connection, String spName, DataRow dataRow) 
2122         { 
2123             if (connection == null) throw new ArgumentNullException("connection"); 
2124             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2125 
2126             // 如果row有值,存储过程必须初始化. 
2127             if (dataRow != null && dataRow.ItemArray.Length > 0) 
2128             { 
2129                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
2130                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
2131 
2132                 // 分配参数值 
2133                 AssignParameterValues(commandParameters, dataRow);
2134 
2135                 return SqlHelper.ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters); 
2136             } 
2137             else 
2138             { 
2139                 return SqlHelper.ExecuteScalar(connection, CommandType.StoredProcedure, spName); 
2140             } 
2141         }
2142 
2143         /// 
 
2144         /// 执行指定连接数据库事务的存储过程,使用DataRow做为参数值,返回结果集中的第一行第一列. 
2145         ///  
2146         /// 一个有效的连接事务 object 
2147         /// 存储过程名称 
2148         /// 使用DataRow作为参数值 
2149         /// 返回结果集中的第一行第一列 
2150         public static object ExecuteScalarTypedParams(SqlTransaction transaction, String spName, DataRow dataRow) 
2151         { 
2152             if (transaction == null) throw new ArgumentNullException("transaction"); 
2153             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 
2154             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2155 
2156             // 如果row有值,存储过程必须初始化. 
2157             if (dataRow != null && dataRow.ItemArray.Length > 0) 
2158             { 
2159                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
2160                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
2161 
2162                 // 分配参数值 
2163                 AssignParameterValues(commandParameters, dataRow);
2164 
2165                 return SqlHelper.ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters); 
2166             } 
2167             else 
2168             { 
2169                 return SqlHelper.ExecuteScalar(transaction, CommandType.StoredProcedure, spName); 
2170             } 
2171         } 
2172         #endregion
2173 
2174         #region ExecuteXmlReaderTypedParams 类型化参数(DataRow) 
2175         /// 
 
2176         /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回XmlReader类型的结果集. 
2177         ///  
2178         /// 一个有效的数据库连接对象 
2179         /// 存储过程名称 
2180         /// 使用DataRow作为参数值 
2181         /// 返回XmlReader结果集对象. 
2182         public static XmlReader ExecuteXmlReaderTypedParams(SqlConnection connection, String spName, DataRow dataRow) 
2183         { 
2184             if (connection == null) throw new ArgumentNullException("connection"); 
2185             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2186 
2187             // 如果row有值,存储过程必须初始化. 
2188             if (dataRow != null && dataRow.ItemArray.Length > 0) 
2189             { 
2190                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
2191                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
2192 
2193                 // 分配参数值 
2194                 AssignParameterValues(commandParameters, dataRow);
2195 
2196                 return SqlHelper.ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters); 
2197             } 
2198             else 
2199             { 
2200                 return SqlHelper.ExecuteXmlReader(connection, CommandType.StoredProcedure, spName); 
2201             } 
2202         }
2203 
2204         /// 
 
2205         /// 执行指定连接数据库事务的存储过程,使用DataRow做为参数值,返回XmlReader类型的结果集. 
2206         ///  
2207         /// 一个有效的连接事务 object 
2208         /// 存储过程名称 
2209         /// 使用DataRow作为参数值 
2210         /// 返回XmlReader结果集对象. 
2211         public static XmlReader ExecuteXmlReaderTypedParams(SqlTransaction transaction, String spName, DataRow dataRow) 
2212         { 
2213             if (transaction == null) throw new ArgumentNullException("transaction"); 
2214             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); 
2215             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2216 
2217             // 如果row有值,存储过程必须初始化. 
2218             if (dataRow != null && dataRow.ItemArray.Length > 0) 
2219             { 
2220                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 
2221                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
2222 
2223                 // 分配参数值 
2224                 AssignParameterValues(commandParameters, dataRow);
2225 
2226                 return SqlHelper.ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName, commandParameters); 
2227             } 
2228             else 
2229             { 
2230                 return SqlHelper.ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName); 
2231             } 
2232         } 
2233         #endregion
2234 
2235     }
2236 
2237     /// 
 
2238     /// SqlHelperParameterCache提供缓存存储过程参数,并能够在运行时从存储过程中探索参数. 
2239     ///  
2240     public sealed class SqlHelperParameterCache 
2241     { 
2242         #region 私有方法,字段,构造函数 
2243         // 私有构造函数,妨止类被实例化. 
2244         private SqlHelperParameterCache() { }
2245 
2246         // 这个方法要注意 
2247         private static Hashtable paramCache = Hashtable.Synchronized(new Hashtable());
2248 
2249         /// 
 
2250         /// 探索运行时的存储过程,返回SqlParameter参数数组. 
2251         /// 初始化参数值为 DBNull.Value. 
2252         ///  
2253         /// 一个有效的数据库连接 
2254         /// 存储过程名称 
2255         /// 是否包含返回值参数 
2256         /// 返回SqlParameter参数数组 
2257         private static SqlParameter[] DiscoverSpParameterSet(SqlConnection connection, string spName, bool includeReturnValueParameter) 
2258         { 
2259             if (connection == null) throw new ArgumentNullException("connection"); 
2260             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2261 
2262             SqlCommand cmd = new SqlCommand(spName, connection); 
2263             cmd.CommandType = CommandType.StoredProcedure;
2264 
2265             connection.Open(); 
2266             // 检索cmd指定的存储过程的参数信息,并填充到cmd的Parameters参数集中. 
2267             SqlCommandBuilder.DeriveParameters(cmd); 
2268             connection.Close(); 
2269             // 如果不包含返回值参数,将参数集中的每一个参数删除. 
2270             if (!includeReturnValueParameter) 
2271             { 
2272                 cmd.Parameters.RemoveAt(0); 
2273             }
2274 
2275             // 创建参数数组 
2276             SqlParameter[] discoveredParameters = new SqlParameter[cmd.Parameters.Count]; 
2277             // 将cmd的Parameters参数集复制到discoveredParameters数组. 
2278             cmd.Parameters.CopyTo(discoveredParameters, 0);
2279 
2280             // 初始化参数值为 DBNull.Value. 
2281             foreach (SqlParameter discoveredParameter in discoveredParameters) 
2282             { 
2283                 discoveredParameter.Value = DBNull.Value; 
2284             } 
2285             return discoveredParameters; 
2286         }
2287 
2288         /// 
 
2289         /// SqlParameter参数数组的深层拷贝. 
2290         ///  
2291         /// 原始参数数组 
2292         /// 返回一个同样的参数数组 
2293         private static SqlParameter[] CloneParameters(SqlParameter[] originalParameters) 
2294         { 
2295             SqlParameter[] clonedParameters = new SqlParameter[originalParameters.Length];
2296 
2297             for (int i = 0, j = originalParameters.Length; i < j; i++) 
2298             { 
2299                 clonedParameters[i] = (SqlParameter)((ICloneable)originalParameters[i]).Clone(); 
2300             }
2301 
2302             return clonedParameters; 
2303         }
2304 
2305         #endregion 私有方法,字段,构造函数结束
2306 
2307         #region 缓存方法
2308 
2309         /// 
 
2310         /// 追加参数数组到缓存. 
2311         ///  
2312         /// 一个有效的数据库连接字符串 
2313         /// 存储过程名或SQL语句 
2314         /// 要缓存的参数数组 
2315         public static void CacheParameterSet(string connectionString, string commandText, params SqlParameter[] commandParameters) 
2316         { 
2317             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 
2318             if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText");
2319 
2320             string hashKey = connectionString + ":" + commandText;
2321 
2322             paramCache[hashKey] = commandParameters; 
2323         }
2324 
2325         /// 
 
2326         /// 从缓存中获取参数数组. 
2327         ///  
2328         /// 一个有效的数据库连接字符 
2329         /// 存储过程名或SQL语句 
2330         /// 参数数组 
2331         public static SqlParameter[] GetCachedParameterSet(string connectionString, string commandText) 
2332         { 
2333             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 
2334             if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText");
2335 
2336             string hashKey = connectionString + ":" + commandText;
2337 
2338             SqlParameter[] cachedParameters = paramCache[hashKey] as SqlParameter[]; 
2339             if (cachedParameters == null) 
2340             { 
2341                 return null; 
2342             } 
2343             else 
2344             { 
2345                 return CloneParameters(cachedParameters); 
2346             } 
2347         }
2348 
2349         #endregion 缓存方法结束
2350 
2351         #region 检索指定的存储过程的参数集
2352 
2353         /// 
 
2354         /// 返回指定的存储过程的参数集 
2355         ///  
2356         ///  
2357         /// 这个方法将查询数据库,并将信息存储到缓存. 
2358         ///  
2359         /// 一个有效的数据库连接字符 
2360         /// 存储过程名 
2361         /// 返回SqlParameter参数数组 
2362         public static SqlParameter[] GetSpParameterSet(string connectionString, string spName) 
2363         { 
2364             return GetSpParameterSet(connectionString, spName, false); 
2365         }
2366 
2367         /// 
 
2368         /// 返回指定的存储过程的参数集 
2369         ///  
2370         ///  
2371         /// 这个方法将查询数据库,并将信息存储到缓存. 
2372         ///  
2373         /// 一个有效的数据库连接字符. 
2374         /// 存储过程名 
2375         /// 是否包含返回值参数 
2376         /// 返回SqlParameter参数数组 
2377         public static SqlParameter[] GetSpParameterSet(string connectionString, string spName, bool includeReturnValueParameter) 
2378         { 
2379             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); 
2380             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2381 
2382             using (SqlConnection connection = new SqlConnection(connectionString)) 
2383             { 
2384                 return GetSpParameterSetInternal(connection, spName, includeReturnValueParameter); 
2385             } 
2386         }
2387 
2388         /// 
 
2389         /// [内部]返回指定的存储过程的参数集(使用连接对象). 
2390         ///  
2391         ///  
2392         /// 这个方法将查询数据库,并将信息存储到缓存. 
2393         ///  
2394         /// 一个有效的数据库连接字符 
2395         /// 存储过程名 
2396         /// 返回SqlParameter参数数组 
2397         internal static SqlParameter[] GetSpParameterSet(SqlConnection connection, string spName) 
2398         { 
2399             return GetSpParameterSet(connection, spName, false); 
2400         }
2401 
2402         /// 
 
2403         /// [内部]返回指定的存储过程的参数集(使用连接对象) 
2404         ///  
2405         ///  
2406         /// 这个方法将查询数据库,并将信息存储到缓存. 
2407         ///  
2408         /// 一个有效的数据库连接对象 
2409         /// 存储过程名 
2410         ///  
2411         /// 是否包含返回值参数 
2412         ///  
2413         /// 返回SqlParameter参数数组 
2414         internal static SqlParameter[] GetSpParameterSet(SqlConnection connection, string spName, bool includeReturnValueParameter) 
2415         { 
2416             if (connection == null) throw new ArgumentNullException("connection"); 
2417             using (SqlConnection clonedConnection = (SqlConnection)((ICloneable)connection).Clone()) 
2418             { 
2419                 return GetSpParameterSetInternal(clonedConnection, spName, includeReturnValueParameter); 
2420             } 
2421         }
2422 
2423         /// 
 
2424         /// [私有]返回指定的存储过程的参数集(使用连接对象) 
2425         ///  
2426         /// 一个有效的数据库连接对象 
2427         /// 存储过程名 
2428         /// 是否包含返回值参数 
2429         /// 返回SqlParameter参数数组 
2430         private static SqlParameter[] GetSpParameterSetInternal(SqlConnection connection, string spName, bool includeReturnValueParameter) 
2431         { 
2432             if (connection == null) throw new ArgumentNullException("connection"); 
2433             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2434 
2435             string hashKey = connection.ConnectionString + ":" + spName + (includeReturnValueParameter ? ":include ReturnValue Parameter" : "");
2436 
2437             SqlParameter[] cachedParameters;
2438 
2439             cachedParameters = paramCache[hashKey] as SqlParameter[]; 
2440             if (cachedParameters == null) 
2441             { 
2442                 SqlParameter[] spParameters = DiscoverSpParameterSet(connection, spName, includeReturnValueParameter); 
2443                 paramCache[hashKey] = spParameters; 
2444                 cachedParameters = spParameters; 
2445             }
2446 
2447             return CloneParameters(cachedParameters); 
2448         }
2449 
2450         #endregion 参数集检索结束
2451 
2452     } 
2453 }
2454 
2455 如果要获取连接数据连接对象或字符串的话，先要修改SQLHelper类中GetConnSting() 方法中的ConfigurationManager.ConnectionStrings["ConStr"].ConnectionString;才能调用。
2456 
2457  
2458 
2459  
2460 
2461  
2462 
2463  
2464 
2465  
2466 
2467  
2468 
2469  
2470 　　

 

转载请注明本文地址： 微软SQLHelper.cs类 中文版