SQLHelper

   1 using System;
   2 
   3 using System.Data;
   4 
   5 using System.Xml;
   6 
   7 using System.Data.SqlClient;
   8 
   9 using System.Collections;
  10 
  11 namespace DRPHelper.Chu
  12 {
  13 
  14     /// <summary>
  15 
  16     /// SqlServer数据访问帮助类
  17 
  18     /// </summary>
  19 
  20     public sealed class SqlHelper
  21     {
  22 
  23         public static SqlConnection connection = new SqlConnection("SERVER=1.1.1.1,21433;DATABASE=Test;PWD=1;UID=sa;");
  24         #region 私有构造函数和方法
  25 
  26         private SqlHelper()
  27         {
  28 
  29         }
  30 
  31         /// <summary>
  32 
  33         /// 将SqlParameter参数数组(参数值)分配给SqlCommand命令.
  34 
  35         /// 这个方法将给任何一个参数分配DBNull.Value;
  36 
  37         /// 该操作将阻止默认值的使用.
  38 
  39         /// </summary>
  40 
  41         /// <param>命令名</param>
  42 
  43         /// <param>SqlParameters数组</param>
  44 
  45         private static void AttachParameters(SqlCommand command, SqlParameter[] commandParameters)
  46         {
  47 
  48             if (command == null) throw new ArgumentNullException("command");
  49 
  50             if (commandParameters != null)
  51             {
  52 
  53                 foreach (SqlParameter p in commandParameters)
  54                 {
  55 
  56                     if (p != null)
  57                     {
  58 
  59                         // 检查未分配值的输出参数,将其分配以DBNull.Value.
  60 
  61                         if ((p.Direction == ParameterDirection.InputOutput || p.Direction == ParameterDirection.Input) &&
  62 
  63                             (p.Value == null))
  64                         {
  65 
  66                             p.Value = DBNull.Value;
  67 
  68                         }
  69 
  70                         command.Parameters.Add(p);
  71 
  72                     }
  73 
  74                 }
  75 
  76             }
  77 
  78         }
  79 
  80 
  81 
  82         /// <summary>
  83 
  84         /// 将DataRow类型的列值分配到SqlParameter参数数组.
  85 
  86         /// </summary>
  87 
  88         /// <param>要分配值的SqlParameter参数数组</param>
  89 
  90         /// <param>将要分配给存储过程参数的DataRow</param>
  91 
  92         private static void AssignParameterValues(SqlParameter[] commandParameters, DataRow dataRow)
  93         {
  94 
  95             if ((commandParameters == null) || (dataRow == null))
  96             {
  97 
  98                 return;
  99 
 100             }
 101 
 102             int i = 0;
 103 
 104             // 设置参数值
 105 
 106             foreach (SqlParameter commandParameter in commandParameters)
 107             {
 108 
 109                 // 创建参数名称,如果不存在,只抛出一个异常.
 110 
 111                 if (commandParameter.ParameterName == null ||
 112 
 113                     commandParameter.ParameterName.Length <= 1)
 114 
 115                     throw new Exception(
 116 
 117                         string.Format("请提供参数{0}一个有效的名称{1}.", i, commandParameter.ParameterName));
 118 
 119                 // 从dataRow的表中获取为参数数组中数组名称的列的索引.
 120 
 121                 // 如果存在和参数名称相同的列,则将列值赋给当前名称的参数.
 122 
 123                 if (dataRow.Table.Columns.IndexOf(commandParameter.ParameterName.Substring(1)) != -1)
 124 
 125                     commandParameter.Value = dataRow[commandParameter.ParameterName.Substring(1)];
 126 
 127                 i++;
 128 
 129             }
 130 
 131         }
 132 
 133 
 134 
 135         /// <summary>
 136 
 137         /// 将一个对象数组分配给SqlParameter参数数组.
 138 
 139         /// </summary>
 140 
 141         /// <param>要分配值的SqlParameter参数数组</param>
 142 
 143         /// <param>将要分配给存储过程参数的对象数组</param>
 144 
 145         private static void AssignParameterValues(SqlParameter[] commandParameters, object[] parameterValues)
 146         {
 147 
 148             if ((commandParameters == null) || (parameterValues == null))
 149             {
 150 
 151                 return;
 152 
 153             }
 154 
 155             // 确保对象数组个数与参数个数匹配,如果不匹配,抛出一个异常.
 156 
 157             if (commandParameters.Length != parameterValues.Length)
 158             {
 159 
 160                 throw new ArgumentException("参数值个数与参数不匹配.");
 161 
 162             }
 163 
 164             // 给参数赋值
 165 
 166             for (int i = 0, j = commandParameters.Length; i < j; i++)
 167             {
 168 
 169                 // If the current array value derives from IDbDataParameter, then assign its Value property
 170 
 171                 if (parameterValues[i] is IDbDataParameter)
 172                 {
 173 
 174                     IDbDataParameter paramInstance = (IDbDataParameter)parameterValues[i];
 175 
 176                     if (paramInstance.Value == null)
 177                     {
 178 
 179                         commandParameters[i].Value = DBNull.Value;
 180 
 181                     }
 182 
 183                     else
 184                     {
 185 
 186                         commandParameters[i].Value = paramInstance.Value;
 187 
 188                     }
 189 
 190                 }
 191 
 192                 else if (parameterValues[i] == null)
 193                 {
 194 
 195                     commandParameters[i].Value = DBNull.Value;
 196 
 197                 }
 198 
 199                 else
 200                 {
 201 
 202                     commandParameters[i].Value = parameterValues[i];
 203 
 204                 }
 205 
 206             }
 207 
 208         }
 209 
 210 
 211 
 212         /// <summary>
 213 
 214         /// 预处理用户提供的命令,数据库连接/事务/命令类型/参数
 215 
 216         /// </summary>
 217 
 218         /// <param>要处理的SqlCommand</param>
 219 
 220         /// <param>数据库连接</param>
 221 
 222         /// <param>一个有效的事务或者是null值</param>
 223 
 224         /// <param>命令类型 (存储过程,命令文本, 其它.)</param>
 225 
 226         /// <param>存储过程名或都T-SQL命令文本</param>
 227 
 228         /// <param>和命令相关联的SqlParameter参数数组,如果没有参数为‘null‘</param>
 229 
 230         /// <param><c>true</c> 如果连接是打开的,则为true,其它情况下为false.</param>
 231 
 232         private static void PrepareCommand(SqlCommand command, SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters, out bool mustCloseConnection)
 233         {
 234 
 235             if (command == null) throw new ArgumentNullException("command");
 236 
 237             if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText");
 238 
 239             // If the provided connection is not open, we will open it
 240 
 241             if (connection.State != ConnectionState.Open)
 242             {
 243 
 244                 mustCloseConnection = true;
 245 
 246                 connection.Open();
 247 
 248             }
 249 
 250             else
 251             {
 252 
 253                 mustCloseConnection = false;
 254 
 255             }
 256 
 257             // 给命令分配一个数据库连接.
 258 
 259             command.Connection = connection;
 260 
 261             // 设置命令文本(存储过程名或SQL语句)
 262 
 263             command.CommandText = commandText;
 264 
 265             // 分配事务
 266 
 267             if (transaction != null)
 268             {
 269 
 270                 if (transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
 271 
 272                 command.Transaction = transaction;
 273 
 274             }
 275 
 276             // 设置命令类型.
 277 
 278             command.CommandType = commandType;
 279 
 280             // 分配命令参数
 281 
 282             if (commandParameters != null)
 283             {
 284 
 285                 AttachParameters(command, commandParameters);
 286 
 287             }
 288 
 289             return;
 290 
 291         }
 292 
 293         #endregion 私有构造函数和方法结束
 294 
 295 
 296 
 297         #region ExecuteNonQuery命令
 298 
 299         /// <summary>
 300 
 301         /// 执行指定连接字符串,类型的SqlCommand.
 302 
 303         /// </summary>
 304 
 305         /// <remarks>
 306 
 307         /// 示例:  
 308 
 309         ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders");
 310 
 311         /// </remarks>
 312 
 313         /// <param>一个有效的数据库连接字符串</param>
 314 
 315         /// <param>命令类型 (存储过程,命令文本, 其它.)</param>
 316 
 317         /// <param>存储过程名称或SQL语句</param>
 318 
 319         /// <returns>返回命令影响的行数</returns>
 320 
 321         public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText)
 322         {
 323 
 324             return ExecuteNonQuery(connectionString, commandType, commandText, (SqlParameter[])null);
 325 
 326         }
 327 
 328 
 329 
 330         /// <summary>
 331 
 332         /// 执行指定连接字符串,类型的SqlCommand.如果没有提供参数,不返回结果.
 333 
 334         /// </summary>
 335 
 336         /// <remarks>
 337 
 338         /// 示例:  
 339 
 340         ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
 341 
 342         /// </remarks>
 343 
 344         /// <param>一个有效的数据库连接字符串</param>
 345 
 346         /// <param>命令类型 (存储过程,命令文本, 其它.)</param>
 347 
 348         /// <param>存储过程名称或SQL语句</param>
 349 
 350         /// <param>SqlParameter参数数组</param>
 351 
 352         /// <returns>返回命令影响的行数</returns>
 353 
 354         public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
 355         {
 356 
 357             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
 358 
 359             using (SqlConnection connection = new SqlConnection(connectionString))
 360             {
 361 
 362                 connection.Open();
 363 
 364                 return ExecuteNonQuery(connection, commandType, commandText, commandParameters);
 365 
 366             }
 367 
 368         }
 369 
 370 
 371 
 372         /// <summary>
 373 
 374         /// 执行指定连接字符串的存储过程,将对象数组的值赋给存储过程参数,
 375 
 376         /// 此方法需要在参数缓存方法中探索参数并生成参数.
 377 
 378         /// </summary>
 379 
 380         /// <remarks>
 381 
 382         /// 这个方法没有提供访问输出参数和返回值.
 383 
 384         /// 示例:  
 385 
 386         ///  int result = ExecuteNonQuery(connString, "PublishOrders", 24, 36);
 387 
 388         /// </remarks>
 389 
 390         /// <param>一个有效的数据库连接字符串/param>
 391 
 392         /// <param>存储过程名称</param>
 393 
 394         /// <param>分配到存储过程输入参数的对象数组</param>
 395 
 396         /// <returns>返回受影响的行数</returns>
 397 
 398         public static int ExecuteNonQuery(string connectionString, string spName, params object[] parameterValues)
 399         {
 400 
 401             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
 402 
 403             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
 404 
 405             // 如果存在参数值
 406 
 407             if ((parameterValues != null) && (parameterValues.Length > 0))
 408             {
 409 
 410                 // 从探索存储过程参数(加载到缓存)并分配给存储过程参数数组.
 411 
 412                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
 413 
 414                 // 给存储过程参数赋值
 415 
 416                 AssignParameterValues(commandParameters, parameterValues);
 417 
 418                 return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);
 419 
 420             }
 421 
 422             else
 423             {
 424 
 425                 // 没有参数情况下
 426 
 427                 return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);
 428 
 429             }
 430 
 431         }
 432 
 433 
 434 
 435         /// <summary>
 436 
 437         /// 执行指定数据库连接对象的命令 
 438 
 439         /// </summary>
 440 
 441         /// <remarks>
 442 
 443         /// 示例:  
 444 
 445         ///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders");
 446 
 447         /// </remarks>
 448 
 449         /// <param>一个有效的数据库连接对象</param>
 450 
 451         /// <param>命令类型(存储过程,命令文本或其它.)</param>
 452 
 453         /// <param>存储过程名称或T-SQL语句</param>
 454 
 455         /// <returns>返回影响的行数</returns>
 456 
 457         public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText)
 458         {
 459 
 460             return ExecuteNonQuery(connection, commandType, commandText, (SqlParameter[])null);
 461 
 462         }
 463 
 464 
 465 
 466         /// <summary>
 467 
 468         /// 执行指定数据库连接对象的命令
 469 
 470         /// </summary>
 471 
 472         /// <remarks>
 473 
 474         /// 示例:  
 475 
 476         ///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
 477 
 478         /// </remarks>
 479 
 480         /// <param>一个有效的数据库连接对象</param>
 481 
 482         /// <param>命令类型(存储过程,命令文本或其它.)</param>
 483 
 484         /// <param>T存储过程名称或T-SQL语句</param>
 485 
 486         /// <param>SqlParamter参数数组</param>
 487 
 488         /// <returns>返回影响的行数</returns>
 489 
 490         public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
 491         {
 492 
 493             if (connection == null) throw new ArgumentNullException("connection");
 494 
 495             // 创建SqlCommand命令,并进行预处理
 496 
 497             SqlCommand cmd = new SqlCommand();
 498 
 499             bool mustCloseConnection = false;
 500 
 501             PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
 502 
 503 
 504 
 505             // Finally, execute the command
 506 
 507             int retval = cmd.ExecuteNonQuery();
 508 
 509 
 510 
 511             // 清除参数,以便再次使用.
 512 
 513             cmd.Parameters.Clear();
 514 
 515             if (mustCloseConnection)
 516 
 517                 connection.Close();
 518 
 519             return retval;
 520 
 521         }
 522 
 523 
 524 
 525         /// <summary>
 526 
 527         /// 执行指定数据库连接对象的命令,将对象数组的值赋给存储过程参数.
 528 
 529         /// </summary>
 530 
 531         /// <remarks>
 532 
 533         /// 此方法不提供访问存储过程输出参数和返回值
 534 
 535         /// 示例:  
 536 
 537         ///  int result = ExecuteNonQuery(conn, "PublishOrders", 24, 36);
 538 
 539         /// </remarks>
 540 
 541         /// <param>一个有效的数据库连接对象</param>
 542 
 543         /// <param>存储过程名</param>
 544 
 545         /// <param>分配给存储过程输入参数的对象数组</param>
 546 
 547         /// <returns>返回影响的行数</returns>
 548 
 549         public static int ExecuteNonQuery(SqlConnection connection, string spName, params object[] parameterValues)
 550         {
 551 
 552             if (connection == null) throw new ArgumentNullException("connection");
 553 
 554             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
 555 
 556             // 如果有参数值
 557 
 558             if ((parameterValues != null) && (parameterValues.Length > 0))
 559             {
 560 
 561                 // 从缓存中加载存储过程参数
 562 
 563                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
 564 
 565                 // 给存储过程分配参数值
 566 
 567                 AssignParameterValues(commandParameters, parameterValues);
 568 
 569                 return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);
 570 
 571             }
 572 
 573             else
 574             {
 575 
 576                 return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);
 577 
 578             }
 579 
 580         }
 581 
 582 
 583 
 584         /// <summary>
 585 
 586         /// 执行带事务的SqlCommand.
 587 
 588         /// </summary>
 589 
 590         /// <remarks>
 591 
 592         /// 示例.:  
 593 
 594         ///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders");
 595 
 596         /// </remarks>
 597 
 598         /// <param>一个有效的数据库连接对象</param>
 599 
 600         /// <param>命令类型(存储过程,命令文本或其它.)</param>
 601 
 602         /// <param>存储过程名称或T-SQL语句</param>
 603 
 604         /// <returns>返回影响的行数/returns>
 605 
 606         public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText)
 607         {
 608 
 609             return ExecuteNonQuery(transaction, commandType, commandText, (SqlParameter[])null);
 610 
 611         }
 612 
 613 
 614 
 615         /// <summary>
 616 
 617         /// 执行带事务的SqlCommand(指定参数).
 618 
 619         /// </summary>
 620 
 621         /// <remarks>
 622 
 623         /// 示例:  
 624 
 625         ///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
 626 
 627         /// </remarks>
 628 
 629         /// <param>一个有效的数据库连接对象</param>
 630 
 631         /// <param>命令类型(存储过程,命令文本或其它.)</param>
 632 
 633         /// <param>存储过程名称或T-SQL语句</param>
 634 
 635         /// <param>SqlParamter参数数组</param>
 636 
 637         /// <returns>返回影响的行数</returns>
 638 
 639         public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
 640         {
 641 
 642             if (transaction == null) throw new ArgumentNullException("transaction");
 643 
 644             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
 645 
 646             // 预处理
 647 
 648             SqlCommand cmd = new SqlCommand();
 649 
 650             bool mustCloseConnection = false;
 651 
 652             PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
 653 
 654 
 655 
 656             // 执行
 657 
 658             int retval = cmd.ExecuteNonQuery();
 659 
 660 
 661 
 662             // 清除参数集,以便再次使用.
 663 
 664             cmd.Parameters.Clear();
 665 
 666             return retval;
 667 
 668         }
 669 
 670 
 671 
 672         /// <summary>
 673 
 674         /// 执行带事务的SqlCommand(指定参数值).
 675 
 676         /// </summary>
 677 
 678         /// <remarks>
 679 
 680         /// 此方法不提供访问存储过程输出参数和返回值
 681 
 682         /// 示例:  
 683 
 684         ///  int result = ExecuteNonQuery(conn, trans, "PublishOrders", 24, 36);
 685 
 686         /// </remarks>
 687 
 688         /// <param>一个有效的数据库连接对象</param>
 689 
 690         /// <param>存储过程名</param>
 691 
 692         /// <param>分配给存储过程输入参数的对象数组</param>
 693 
 694         /// <returns>返回受影响的行数</returns>
 695 
 696         public static int ExecuteNonQuery(SqlTransaction transaction, string spName, params object[] parameterValues)
 697         {
 698 
 699             if (transaction == null) throw new ArgumentNullException("transaction");
 700 
 701             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
 702 
 703             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
 704 
 705             // 如果有参数值
 706 
 707             if ((parameterValues != null) && (parameterValues.Length > 0))
 708             {
 709 
 710                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
 711 
 712                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
 713 
 714                 // 给存储过程参数赋值
 715 
 716                 AssignParameterValues(commandParameters, parameterValues);
 717 
 718                 // 调用重载方法
 719 
 720                 return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters);
 721 
 722             }
 723 
 724             else
 725             {
 726 
 727                 // 没有参数值
 728 
 729                 return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);
 730 
 731             }
 732 
 733         }
 734 
 735         #endregion ExecuteNonQuery方法结束
 736 
 737 
 738 
 739         #region ExecuteDataset方法
 740 
 741         /// <summary>
 742 
 743         /// 执行指定数据库连接字符串的命令,返回DataSet.
 744 
 745         /// </summary>
 746 
 747         /// <remarks>
 748 
 749         /// 示例:  
 750 
 751         ///  DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders");
 752 
 753         /// </remarks>
 754 
 755         /// <param>一个有效的数据库连接字符串</param>
 756 
 757         /// <param>命令类型 (存储过程,命令文本或其它)</param>
 758 
 759         /// <param>存储过程名称或T-SQL语句</param>
 760 
 761         /// <returns>返回一个包含结果集的DataSet</returns>
 762 
 763         public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText)
 764         {
 765 
 766             return ExecuteDataset(connectionString, commandType, commandText, (SqlParameter[])null);
 767 
 768         }
 769 
 770 
 771 
 772         /// <summary>
 773 
 774         /// 执行指定数据库连接字符串的命令,返回DataSet.
 775 
 776         /// </summary>
 777 
 778         /// <remarks>
 779 
 780         /// 示例: 
 781 
 782         ///  DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
 783 
 784         /// </remarks>
 785 
 786         /// <param>一个有效的数据库连接字符串</param>
 787 
 788         /// <param>命令类型 (存储过程,命令文本或其它)</param>
 789 
 790         /// <param>存储过程名称或T-SQL语句</param>
 791 
 792         /// <param>SqlParamters参数数组</param>
 793 
 794         /// <returns>返回一个包含结果集的DataSet</returns>
 795 
 796         public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
 797         {
 798 
 799             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
 800 
 801             // 创建并打开数据库连接对象,操作完成释放对象.
 802 
 803             using (SqlConnection connection = new SqlConnection(connectionString))
 804             {
 805 
 806                 connection.Open();
 807 
 808                 // 调用指定数据库连接字符串重载方法.
 809 
 810                 return ExecuteDataset(connection, commandType, commandText, commandParameters);
 811 
 812             }
 813 
 814         }
 815 
 816 
 817 
 818         /// <summary>
 819 
 820         /// 执行指定数据库连接字符串的命令,直接提供参数值,返回DataSet.
 821 
 822         /// </summary>
 823 
 824         /// <remarks>
 825 
 826         /// 此方法不提供访问存储过程输出参数和返回值.
 827 
 828         /// 示例: 
 829 
 830         ///  DataSet ds = ExecuteDataset(connString, "GetOrders", 24, 36);
 831 
 832         /// </remarks>
 833 
 834         /// <param>一个有效的数据库连接字符串</param>
 835 
 836         /// <param>存储过程名</param>
 837 
 838         /// <param>分配给存储过程输入参数的对象数组</param>
 839 
 840         /// <returns>返回一个包含结果集的DataSet</returns>
 841 
 842         public static DataSet ExecuteDataset(string connectionString, string spName, params object[] parameterValues)
 843         {
 844 
 845             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
 846 
 847             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
 848 
 849 
 850 
 851             if ((parameterValues != null) && (parameterValues.Length > 0))
 852             {
 853 
 854                 // 从缓存中检索存储过程参数
 855 
 856                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
 857 
 858                 // 给存储过程参数分配值
 859 
 860                 AssignParameterValues(commandParameters, parameterValues);
 861 
 862                 return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);
 863 
 864             }
 865 
 866             else
 867             {
 868 
 869                 return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);
 870 
 871             }
 872 
 873         }
 874 
 875 
 876 
 877         /// <summary>
 878 
 879         /// 执行指定数据库连接对象的命令,返回DataSet.
 880 
 881         /// </summary>
 882 
 883         /// <remarks>
 884 
 885         /// 示例:  
 886 
 887         ///  DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders");
 888 
 889         /// </remarks>
 890 
 891         /// <param>一个有效的数据库连接对象</param>
 892 
 893         /// <param>命令类型 (存储过程,命令文本或其它)</param>
 894 
 895         /// <param>存储过程名或T-SQL语句</param>
 896 
 897         /// <returns>返回一个包含结果集的DataSet</returns>
 898 
 899         public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText)
 900         {
 901 
 902             return ExecuteDataset(connection, commandType, commandText, (SqlParameter[])null);
 903 
 904         }
 905 
 906 
 907 
 908         /// <summary>
 909 
 910         /// 执行指定数据库连接对象的命令,指定存储过程参数,返回DataSet.
 911 
 912         /// </summary>
 913 
 914         /// <remarks>
 915 
 916         /// 示例:  
 917 
 918         ///  DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
 919 
 920         /// </remarks>
 921 
 922         /// <param>一个有效的数据库连接对象</param>
 923 
 924         /// <param>命令类型 (存储过程,命令文本或其它)</param>
 925 
 926         /// <param>存储过程名或T-SQL语句</param>
 927 
 928         /// <param>SqlParamter参数数组</param>
 929 
 930         /// <returns>返回一个包含结果集的DataSet</returns>
 931 
 932         public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
 933         {
 934 
 935             if (connection == null) throw new ArgumentNullException("connection");
 936 
 937             // 预处理
 938 
 939             SqlCommand cmd = new SqlCommand();
 940 
 941             bool mustCloseConnection = false;
 942 
 943             PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
 944 
 945 
 946 
 947             // 创建SqlDataAdapter和DataSet.
 948 
 949             using (SqlDataAdapter da = new SqlDataAdapter(cmd))
 950             {
 951 
 952                 DataSet ds = new DataSet();
 953 
 954                 // 填充DataSet.
 955 
 956                 da.Fill(ds);
 957 
 958 
 959 
 960                 cmd.Parameters.Clear();
 961 
 962                 if (mustCloseConnection)
 963 
 964                     connection.Close();
 965 
 966                 return ds;
 967 
 968             }
 969 
 970         }
 971 
 972 
 973 
 974         /// <summary>
 975 
 976         /// 执行指定数据库连接对象的命令,指定参数值,返回DataSet.
 977 
 978         /// </summary>
 979 
 980         /// <remarks>
 981 
 982         /// 此方法不提供访问存储过程输入参数和返回值.
 983 
 984         /// 示例.:  
 985 
 986         ///  DataSet ds = ExecuteDataset(conn, "GetOrders", 24, 36);
 987 
 988         /// </remarks>
 989 
 990         /// <param>一个有效的数据库连接对象</param>
 991 
 992         /// <param>存储过程名</param>
 993 
 994         /// <param>分配给存储过程输入参数的对象数组</param>
 995 
 996         /// <returns>返回一个包含结果集的DataSet</returns>
 997 
 998         public static DataSet ExecuteDataset(SqlConnection connection, string spName, params object[] parameterValues)
 999         {
1000 
1001             if (connection == null) throw new ArgumentNullException("connection");
1002 
1003             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1004 
1005             if ((parameterValues != null) && (parameterValues.Length > 0))
1006             {
1007 
1008                 // 比缓存中加载存储过程参数
1009 
1010                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1011 
1012                 // 给存储过程参数分配值
1013 
1014                 AssignParameterValues(commandParameters, parameterValues);
1015 
1016                 return ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters);
1017 
1018             }
1019 
1020             else
1021             {
1022 
1023                 return ExecuteDataset(connection, CommandType.StoredProcedure, spName);
1024 
1025             }
1026 
1027         }
1028 
1029 
1030 
1031         /// <summary>
1032 
1033         /// 执行指定事务的命令,返回DataSet.
1034 
1035         /// </summary>
1036 
1037         /// <remarks>
1038 
1039         /// 示例:  
1040 
1041         ///  DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders");
1042 
1043         /// </remarks>
1044 
1045         /// <param>事务</param>
1046 
1047         /// <param>命令类型 (存储过程,命令文本或其它)</param>
1048 
1049         /// <param>存储过程名或T-SQL语句</param>
1050 
1051         /// <returns>返回一个包含结果集的DataSet</returns>
1052 
1053         public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText)
1054         {
1055 
1056             return ExecuteDataset(transaction, commandType, commandText, (SqlParameter[])null);
1057 
1058         }
1059 
1060 
1061 
1062         /// <summary>
1063 
1064         /// 执行指定事务的命令,指定参数,返回DataSet.
1065 
1066         /// </summary>
1067 
1068         /// <remarks>
1069 
1070         /// 示例:  
1071 
1072         ///  DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
1073 
1074         /// </remarks>
1075 
1076         /// <param>事务</param>
1077 
1078         /// <param>命令类型 (存储过程,命令文本或其它)</param>
1079 
1080         /// <param>存储过程名或T-SQL语句</param>
1081 
1082         /// <param>SqlParamter参数数组</param>
1083 
1084         /// <returns>返回一个包含结果集的DataSet</returns>
1085 
1086         public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
1087         {
1088 
1089             if (transaction == null) throw new ArgumentNullException("transaction");
1090 
1091             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
1092 
1093             // 预处理
1094 
1095             SqlCommand cmd = new SqlCommand();
1096 
1097             bool mustCloseConnection = false;
1098 
1099             PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
1100 
1101 
1102 
1103             // 创建 DataAdapter & DataSet
1104 
1105             using (SqlDataAdapter da = new SqlDataAdapter(cmd))
1106             {
1107 
1108                 DataSet ds = new DataSet();
1109 
1110                 da.Fill(ds);
1111 
1112                 cmd.Parameters.Clear();
1113 
1114                 return ds;
1115 
1116             }
1117 
1118         }
1119 
1120 
1121 
1122         /// <summary>
1123 
1124         /// 执行指定事务的命令,指定参数值,返回DataSet.
1125 
1126         /// </summary>
1127 
1128         /// <remarks>
1129 
1130         /// 此方法不提供访问存储过程输入参数和返回值.
1131 
1132         /// 示例.:  
1133 
1134         ///  DataSet ds = ExecuteDataset(trans, "GetOrders", 24, 36);
1135 
1136         /// </remarks>
1137 
1138         /// <param>事务</param>
1139 
1140         /// <param>存储过程名</param>
1141 
1142         /// <param>分配给存储过程输入参数的对象数组</param>
1143 
1144         /// <returns>返回一个包含结果集的DataSet</returns>
1145 
1146         public static DataSet ExecuteDataset(SqlTransaction transaction, string spName, params object[] parameterValues)
1147         {
1148 
1149             if (transaction == null) throw new ArgumentNullException("transaction");
1150 
1151             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
1152 
1153             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1154 
1155 
1156 
1157             if ((parameterValues != null) && (parameterValues.Length > 0))
1158             {
1159 
1160                 // 从缓存中加载存储过程参数
1161 
1162                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
1163 
1164                 // 给存储过程参数分配值
1165 
1166                 AssignParameterValues(commandParameters, parameterValues);
1167 
1168                 return ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters);
1169 
1170             }
1171 
1172             else
1173             {
1174 
1175                 return ExecuteDataset(transaction, CommandType.StoredProcedure, spName);
1176 
1177             }
1178 
1179         }
1180 
1181         #endregion ExecuteDataset数据集命令结束
1182 
1183 
1184 
1185         #region ExecuteReader 数据阅读器
1186 
1187         /// <summary>
1188 
1189         /// 枚举,标识数据库连接是由SqlHelper提供还是由调用者提供
1190 
1191         /// </summary>
1192 
1193         private enum SqlConnectionOwnership
1194         {
1195 
1196             /// <summary>由SqlHelper提供连接</summary>
1197 
1198             Internal,
1199 
1200             /// <summary>由调用者提供连接</summary>
1201 
1202             External
1203 
1204         }
1205 
1206 
1207 
1208         /// <summary>
1209 
1210         /// 执行指定数据库连接对象的数据阅读器.
1211 
1212         /// </summary>
1213 
1214         /// <remarks>
1215 
1216         /// 如果是SqlHelper打开连接,当连接关闭DataReader也将关闭.
1217 
1218         /// 如果是调用都打开连接,DataReader由调用都管理.
1219 
1220         /// </remarks>
1221 
1222         /// <param>一个有效的数据库连接对象</param>
1223 
1224         /// <param>一个有效的事务,或者为 ‘null‘</param>
1225 
1226         /// <param>命令类型 (存储过程,命令文本或其它)</param>
1227 
1228         /// <param>存储过程名或T-SQL语句</param>
1229 
1230         /// <param>SqlParameters参数数组,如果没有参数则为‘null‘</param>
1231 
1232         /// <param>标识数据库连接对象是由调用者提供还是由SqlHelper提供</param>
1233 
1234         /// <returns>返回包含结果集的SqlDataReader</returns>
1235 
1236         private static SqlDataReader ExecuteReader(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters, SqlConnectionOwnership connectionOwnership)
1237         {
1238 
1239             if (connection == null) throw new ArgumentNullException("connection");
1240 
1241             bool mustCloseConnection = false;
1242 
1243             // 创建命令
1244 
1245             SqlCommand cmd = new SqlCommand();
1246 
1247             try
1248             {
1249 
1250                 PrepareCommand(cmd, connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
1251 
1252 
1253 
1254                 // 创建数据阅读器
1255 
1256                 SqlDataReader dataReader;
1257 
1258                 if (connectionOwnership == SqlConnectionOwnership.External)
1259                 {
1260 
1261                     dataReader = cmd.ExecuteReader();
1262 
1263                 }
1264 
1265                 else
1266                 {
1267 
1268                     dataReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
1269 
1270                 }
1271 
1272 
1273 
1274                 // 清除参数,以便再次使用..
1275 
1276                 // HACK: There is a problem here, the output parameter values are fletched 
1277 
1278                 // when the reader is closed, so if the parameters are detached from the command
1279 
1280                 // then the SqlReader can磘 set its values. 
1281 
1282                 // When this happen, the parameters can磘 be used again in other command.
1283 
1284                 bool canClear = true;
1285 
1286                 foreach (SqlParameter commandParameter in cmd.Parameters)
1287                 {
1288 
1289                     if (commandParameter.Direction != ParameterDirection.Input)
1290 
1291                         canClear = false;
1292 
1293                 }
1294 
1295 
1296 
1297                 if (canClear)
1298                 {
1299 
1300                     cmd.Parameters.Clear();
1301 
1302                 }
1303 
1304                 return dataReader;
1305 
1306             }
1307 
1308             catch
1309             {
1310 
1311                 if (mustCloseConnection)
1312 
1313                     connection.Close();
1314 
1315                 throw;
1316 
1317             }
1318 
1319         }
1320 
1321 
1322 
1323         /// <summary>
1324 
1325         /// 执行指定数据库连接字符串的数据阅读器.
1326 
1327         /// </summary>
1328 
1329         /// <remarks>
1330 
1331         /// 示例:  
1332 
1333         ///  SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders");
1334 
1335         /// </remarks>
1336 
1337         /// <param>一个有效的数据库连接字符串</param>
1338 
1339         /// <param>命令类型 (存储过程,命令文本或其它)</param>
1340 
1341         /// <param>存储过程名或T-SQL语句</param>
1342 
1343         /// <returns>返回包含结果集的SqlDataReader</returns>
1344 
1345         public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText)
1346         {
1347 
1348             return ExecuteReader(connectionString, commandType, commandText, (SqlParameter[])null);
1349 
1350         }
1351 
1352 
1353 
1354         /// <summary>
1355 
1356         /// 执行指定数据库连接字符串的数据阅读器,指定参数.
1357 
1358         /// </summary>
1359 
1360         /// <remarks>
1361 
1362         /// 示例:  
1363 
1364         ///  SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
1365 
1366         /// </remarks>
1367 
1368         /// <param>一个有效的数据库连接字符串</param>
1369 
1370         /// <param>命令类型 (存储过程,命令文本或其它)</param>
1371 
1372         /// <param>存储过程名或T-SQL语句</param>
1373 
1374         /// <param>SqlParamter参数数组(new SqlParameter("@prodid", 24))</param>
1375 
1376         /// <returns>返回包含结果集的SqlDataReader</returns>
1377 
1378         public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
1379         {
1380 
1381             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
1382 
1383             SqlConnection connection = null;
1384 
1385             try
1386             {
1387 
1388                 connection = new SqlConnection(connectionString);
1389 
1390                 connection.Open();
1391 
1392                 return ExecuteReader(connection, null, commandType, commandText, commandParameters, SqlConnectionOwnership.Internal);
1393 
1394             }
1395 
1396             catch
1397             {
1398 
1399                 // If we fail to return the SqlDatReader, we need to close the connection ourselves
1400 
1401                 if (connection != null) connection.Close();
1402 
1403                 throw;
1404 
1405             }
1406 
1407 
1408 
1409         }
1410 
1411 
1412 
1413         /// <summary>
1414 
1415         /// 执行指定数据库连接字符串的数据阅读器,指定参数值.
1416 
1417         /// </summary>
1418 
1419         /// <remarks>
1420 
1421         /// 此方法不提供访问存储过程输出参数和返回值参数.
1422 
1423         /// 示例:  
1424 
1425         ///  SqlDataReader dr = ExecuteReader(connString, "GetOrders", 24, 36);
1426 
1427         /// </remarks>
1428 
1429         /// <param>一个有效的数据库连接字符串</param>
1430 
1431         /// <param>存储过程名</param>
1432 
1433         /// <param>分配给存储过程输入参数的对象数组</param>
1434 
1435         /// <returns>返回包含结果集的SqlDataReader</returns>
1436 
1437         public static SqlDataReader ExecuteReader(string connectionString, string spName, params object[] parameterValues)
1438         {
1439 
1440             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
1441 
1442             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1443 
1444 
1445 
1446             if ((parameterValues != null) && (parameterValues.Length > 0))
1447             {
1448 
1449                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
1450 
1451                 AssignParameterValues(commandParameters, parameterValues);
1452 
1453                 return ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters);
1454 
1455             }
1456 
1457             else
1458             {
1459 
1460                 return ExecuteReader(connectionString, CommandType.StoredProcedure, spName);
1461 
1462             }
1463 
1464         }
1465 
1466 
1467 
1468         /// <summary>
1469 
1470         /// 执行指定数据库连接对象的数据阅读器.
1471 
1472         /// </summary>
1473 
1474         /// <remarks>
1475 
1476         /// 示例:  
1477 
1478         ///  SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders");
1479 
1480         /// </remarks>
1481 
1482         /// <param>一个有效的数据库连接对象</param>
1483 
1484         /// <param>命令类型 (存储过程,命令文本或其它)</param>
1485 
1486         /// <param>存储过程名或T-SQL语句</param>
1487 
1488         /// <returns>返回包含结果集的SqlDataReader</returns>
1489 
1490         public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText)
1491         {
1492 
1493             return ExecuteReader(connection, commandType, commandText, (SqlParameter[])null);
1494 
1495         }
1496 
1497 
1498 
1499         /// <summary>
1500 
1501         /// [调用者方式]执行指定数据库连接对象的数据阅读器,指定参数.
1502 
1503         /// </summary>
1504 
1505         /// <remarks>
1506 
1507         /// 示例:  
1508 
1509         ///  SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
1510 
1511         /// </remarks>
1512 
1513         /// <param>一个有效的数据库连接对象</param>
1514 
1515         /// <param>命令类型 (存储过程,命令文本或其它)</param>
1516 
1517         /// <param>命令类型 (存储过程,命令文本或其它)</param>
1518 
1519         /// <param>SqlParamter参数数组</param>
1520 
1521         /// <returns>返回包含结果集的SqlDataReader</returns>
1522 
1523         public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
1524         {
1525 
1526             return ExecuteReader(connection, (SqlTransaction)null, commandType, commandText, commandParameters, SqlConnectionOwnership.External);
1527 
1528         }
1529 
1530 
1531 
1532         /// <summary>
1533 
1534         /// [调用者方式]执行指定数据库连接对象的数据阅读器,指定参数值.
1535 
1536         /// </summary>
1537 
1538         /// <remarks>
1539 
1540         /// 此方法不提供访问存储过程输出参数和返回值参数.
1541 
1542         /// 示例:  
1543 
1544         ///  SqlDataReader dr = ExecuteReader(conn, "GetOrders", 24, 36);
1545 
1546         /// </remarks>
1547 
1548         /// <param>一个有效的数据库连接对象</param>
1549 
1550         /// <param>T存储过程名</param>
1551 
1552         /// <param>分配给存储过程输入参数的对象数组</param>
1553 
1554         /// <returns>返回包含结果集的SqlDataReader</returns>
1555 
1556         public static SqlDataReader ExecuteReader(SqlConnection connection, string spName, params object[] parameterValues)
1557         {
1558 
1559             if (connection == null) throw new ArgumentNullException("connection");
1560 
1561             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1562 
1563             if ((parameterValues != null) && (parameterValues.Length > 0))
1564             {
1565 
1566                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1567 
1568                 AssignParameterValues(commandParameters, parameterValues);
1569 
1570                 return ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters);
1571 
1572             }
1573 
1574             else
1575             {
1576 
1577                 return ExecuteReader(connection, CommandType.StoredProcedure, spName);
1578 
1579             }
1580 
1581         }
1582 
1583 
1584 
1585         /// <summary>
1586 
1587         /// [调用者方式]执行指定数据库事务的数据阅读器,指定参数值.
1588 
1589         /// </summary>
1590 
1591         /// <remarks>
1592 
1593         /// 示例:  
1594 
1595         ///  SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders");
1596 
1597         /// </remarks>
1598 
1599         /// <param>一个有效的连接事务</param>
1600 
1601         /// <param>命令类型 (存储过程,命令文本或其它)</param>
1602 
1603         /// <param>存储过程名称或T-SQL语句</param>
1604 
1605         /// <returns>返回包含结果集的SqlDataReader</returns>
1606 
1607         public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText)
1608         {
1609 
1610             return ExecuteReader(transaction, commandType, commandText, (SqlParameter[])null);
1611 
1612         }
1613 
1614 
1615 
1616         /// <summary>
1617 
1618         /// [调用者方式]执行指定数据库事务的数据阅读器,指定参数.
1619 
1620         /// </summary>
1621 
1622         /// <remarks>
1623 
1624         /// 示例:  
1625 
1626         ///   SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
1627 
1628         /// </remarks>
1629 
1630         /// <param>一个有效的连接事务</param>
1631 
1632         /// <param>命令类型 (存储过程,命令文本或其它)</param>
1633 
1634         /// <param>存储过程名称或T-SQL语句</param>
1635 
1636         /// <param>分配给命令的SqlParamter参数数组</param>
1637 
1638         /// <returns>返回包含结果集的SqlDataReader</returns>
1639 
1640         public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
1641         {
1642 
1643             if (transaction == null) throw new ArgumentNullException("transaction");
1644 
1645             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
1646 
1647             return ExecuteReader(transaction.Connection, transaction, commandType, commandText, commandParameters, SqlConnectionOwnership.External);
1648 
1649         }
1650 
1651 
1652 
1653         /// <summary>
1654 
1655         /// [调用者方式]执行指定数据库事务的数据阅读器,指定参数值.
1656 
1657         /// </summary>
1658 
1659         /// <remarks>
1660 
1661         /// 此方法不提供访问存储过程输出参数和返回值参数.
1662 
1663         /// 
1664 
1665         /// 示例:  
1666 
1667         ///  SqlDataReader dr = ExecuteReader(trans, "GetOrders", 24, 36);
1668 
1669         /// </remarks>
1670 
1671         /// <param>一个有效的连接事务</param>
1672 
1673         /// <param>存储过程名称</param>
1674 
1675         /// <param>分配给存储过程输入参数的对象数组</param>
1676 
1677         /// <returns>返回包含结果集的SqlDataReader</returns>
1678 
1679         public static SqlDataReader ExecuteReader(SqlTransaction transaction, string spName, params object[] parameterValues)
1680         {
1681 
1682             if (transaction == null) throw new ArgumentNullException("transaction");
1683 
1684             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
1685 
1686             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1687 
1688             // 如果有参数值
1689 
1690             if ((parameterValues != null) && (parameterValues.Length > 0))
1691             {
1692 
1693                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
1694 
1695                 AssignParameterValues(commandParameters, parameterValues);
1696 
1697                 return ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
1698 
1699             }
1700 
1701             else
1702             {
1703 
1704                 // 没有参数值
1705 
1706                 return ExecuteReader(transaction, CommandType.StoredProcedure, spName);
1707 
1708             }
1709 
1710         }
1711 
1712         #endregion ExecuteReader数据阅读器
1713 
1714 
1715 
1716         #region ExecuteScalar 返回结果集中的第一行第一列
1717 
1718         /// <summary>
1719 
1720         /// 执行指定数据库连接字符串的命令,返回结果集中的第一行第一列.
1721 
1722         /// </summary>
1723 
1724         /// <remarks>
1725 
1726         /// 示例:  
1727 
1728         ///  int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount");
1729 
1730         /// </remarks>
1731 
1732         /// <param>一个有效的数据库连接字符串</param>
1733 
1734         /// <param>命令类型 (存储过程,命令文本或其它)</param>
1735 
1736         /// <param>存储过程名称或T-SQL语句</param>
1737 
1738         /// <returns>返回结果集中的第一行第一列</returns>
1739 
1740         public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText)
1741         {
1742 
1743             // 执行参数为空的方法
1744 
1745             return ExecuteScalar(connectionString, commandType, commandText, (SqlParameter[])null);
1746 
1747         }
1748 
1749 
1750 
1751         /// <summary>
1752 
1753         /// 执行指定数据库连接字符串的命令,指定参数,返回结果集中的第一行第一列.
1754 
1755         /// </summary>
1756 
1757         /// <remarks>
1758 
1759         /// 示例:  
1760 
1761         ///  int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
1762 
1763         /// </remarks>
1764 
1765         /// <param>一个有效的数据库连接字符串</param>
1766 
1767         /// <param>命令类型 (存储过程,命令文本或其它)</param>
1768 
1769         /// <param>存储过程名称或T-SQL语句</param>
1770 
1771         /// <param>分配给命令的SqlParamter参数数组</param>
1772 
1773         /// <returns>返回结果集中的第一行第一列</returns>
1774 
1775         public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
1776         {
1777 
1778             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
1779 
1780             // 创建并打开数据库连接对象,操作完成释放对象.
1781 
1782             using (SqlConnection connection = new SqlConnection(connectionString))
1783             {
1784 
1785                 connection.Open();
1786 
1787                 // 调用指定数据库连接字符串重载方法.
1788 
1789                 return ExecuteScalar(connection, commandType, commandText, commandParameters);
1790 
1791             }
1792 
1793         }
1794 
1795 
1796 
1797         /// <summary>
1798 
1799         /// 执行指定数据库连接字符串的命令,指定参数值,返回结果集中的第一行第一列.
1800 
1801         /// </summary>
1802 
1803         /// <remarks>
1804 
1805         /// 此方法不提供访问存储过程输出参数和返回值参数.
1806 
1807         /// 
1808 
1809         /// 示例:  
1810 
1811         ///  int orderCount = (int)ExecuteScalar(connString, "GetOrderCount", 24, 36);
1812 
1813         /// </remarks>
1814 
1815         /// <param>一个有效的数据库连接字符串</param>
1816 
1817         /// <param>存储过程名称</param>
1818 
1819         /// <param>分配给存储过程输入参数的对象数组</param>
1820 
1821         /// <returns>返回结果集中的第一行第一列</returns>
1822 
1823         public static object ExecuteScalar(string connectionString, string spName, params object[] parameterValues)
1824         {
1825 
1826             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
1827 
1828             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1829 
1830 
1831 
1832             // 如果有参数值
1833 
1834             if ((parameterValues != null) && (parameterValues.Length > 0))
1835             {
1836 
1837                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
1838 
1839                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
1840 
1841                 // 给存储过程参数赋值
1842 
1843                 AssignParameterValues(commandParameters, parameterValues);
1844 
1845                 // 调用重载方法
1846 
1847                 return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters);
1848 
1849             }
1850 
1851             else
1852             {
1853 
1854                 // 没有参数值
1855 
1856                 return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName);
1857 
1858             }
1859 
1860         }
1861 
1862 
1863 
1864         /// <summary>
1865 
1866         /// 执行指定数据库连接对象的命令,返回结果集中的第一行第一列.
1867 
1868         /// </summary>
1869 
1870         /// <remarks>
1871 
1872         /// 示例:  
1873 
1874         ///  int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount");
1875 
1876         /// </remarks>
1877 
1878         /// <param>一个有效的数据库连接对象</param>
1879 
1880         /// <param>命令类型 (存储过程,命令文本或其它)</param>
1881 
1882         /// <param>存储过程名称或T-SQL语句</param>
1883 
1884         /// <returns>返回结果集中的第一行第一列</returns>
1885 
1886         public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText)
1887         {
1888 
1889             // 执行参数为空的方法
1890 
1891             return ExecuteScalar(connection, commandType, commandText, (SqlParameter[])null);
1892 
1893         }
1894 
1895 
1896 
1897         /// <summary>
1898 
1899         /// 执行指定数据库连接对象的命令,指定参数,返回结果集中的第一行第一列.
1900 
1901         /// </summary>
1902 
1903         /// <remarks>
1904 
1905         /// 示例:  
1906 
1907         ///  int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
1908 
1909         /// </remarks>
1910 
1911         /// <param>一个有效的数据库连接对象</param>
1912 
1913         /// <param>命令类型 (存储过程,命令文本或其它)</param>
1914 
1915         /// <param>存储过程名称或T-SQL语句</param>
1916 
1917         /// <param>分配给命令的SqlParamter参数数组</param>
1918 
1919         /// <returns>返回结果集中的第一行第一列</returns>
1920 
1921         public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
1922         {
1923 
1924             if (connection == null) throw new ArgumentNullException("connection");
1925 
1926             // 创建SqlCommand命令,并进行预处理
1927 
1928             SqlCommand cmd = new SqlCommand();
1929 
1930             bool mustCloseConnection = false;
1931 
1932             PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
1933 
1934 
1935 
1936             // 执行SqlCommand命令,并返回结果.
1937 
1938             object retval = cmd.ExecuteScalar();
1939 
1940 
1941 
1942             // 清除参数,以便再次使用.
1943 
1944             cmd.Parameters.Clear();
1945 
1946             if (mustCloseConnection)
1947 
1948                 connection.Close();
1949 
1950             return retval;
1951 
1952         }
1953 
1954 
1955 
1956         /// <summary>
1957 
1958         /// 执行指定数据库连接对象的命令,指定参数值,返回结果集中的第一行第一列.
1959 
1960         /// </summary>
1961 
1962         /// <remarks>
1963 
1964         /// 此方法不提供访问存储过程输出参数和返回值参数.
1965 
1966         /// 
1967 
1968         /// 示例:  
1969 
1970         ///  int orderCount = (int)ExecuteScalar(conn, "GetOrderCount", 24, 36);
1971 
1972         /// </remarks>
1973 
1974         /// <param>一个有效的数据库连接对象</param>
1975 
1976         /// <param>存储过程名称</param>
1977 
1978         /// <param>分配给存储过程输入参数的对象数组</param>
1979 
1980         /// <returns>返回结果集中的第一行第一列</returns>
1981 
1982         public static object ExecuteScalar(SqlConnection connection, string spName, params object[] parameterValues)
1983         {
1984 
1985             if (connection == null) throw new ArgumentNullException("connection");
1986 
1987             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1988 
1989             // 如果有参数值
1990 
1991             if ((parameterValues != null) && (parameterValues.Length > 0))
1992             {
1993 
1994                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
1995 
1996                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1997 
1998                 // 给存储过程参数赋值
1999 
2000                 AssignParameterValues(commandParameters, parameterValues);
2001 
2002                 // 调用重载方法
2003 
2004                 return ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters);
2005 
2006             }
2007 
2008             else
2009             {
2010 
2011                 // 没有参数值
2012 
2013                 return ExecuteScalar(connection, CommandType.StoredProcedure, spName);
2014 
2015             }
2016 
2017         }
2018 
2019 
2020 
2021         /// <summary>
2022 
2023         /// 执行指定数据库事务的命令,返回结果集中的第一行第一列.
2024 
2025         /// </summary>
2026 
2027         /// <remarks>
2028 
2029         /// 示例:  
2030 
2031         ///  int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount");
2032 
2033         /// </remarks>
2034 
2035         /// <param>一个有效的连接事务</param>
2036 
2037         /// <param>命令类型 (存储过程,命令文本或其它)</param>
2038 
2039         /// <param>存储过程名称或T-SQL语句</param>
2040 
2041         /// <returns>返回结果集中的第一行第一列</returns>
2042 
2043         public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText)
2044         {
2045 
2046             // 执行参数为空的方法
2047 
2048             return ExecuteScalar(transaction, commandType, commandText, (SqlParameter[])null);
2049 
2050         }
2051 
2052 
2053 
2054         /// <summary>
2055 
2056         /// 执行指定数据库事务的命令,指定参数,返回结果集中的第一行第一列.
2057 
2058         /// </summary>
2059 
2060         /// <remarks>
2061 
2062         /// 示例:  
2063 
2064         ///  int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
2065 
2066         /// </remarks>
2067 
2068         /// <param>一个有效的连接事务</param>
2069 
2070         /// <param>命令类型 (存储过程,命令文本或其它)</param>
2071 
2072         /// <param>存储过程名称或T-SQL语句</param>
2073 
2074         /// <param>分配给命令的SqlParamter参数数组</param>
2075 
2076         /// <returns>返回结果集中的第一行第一列</returns>
2077 
2078         public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
2079         {
2080 
2081             if (transaction == null) throw new ArgumentNullException("transaction");
2082 
2083             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
2084 
2085             // 创建SqlCommand命令,并进行预处理
2086 
2087             SqlCommand cmd = new SqlCommand();
2088 
2089             bool mustCloseConnection = false;
2090 
2091             PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
2092 
2093 
2094 
2095             // 执行SqlCommand命令,并返回结果.
2096 
2097             object retval = cmd.ExecuteScalar();
2098 
2099 
2100 
2101             // 清除参数,以便再次使用.
2102 
2103             cmd.Parameters.Clear();
2104 
2105             return retval;
2106 
2107         }
2108 
2109 
2110 
2111         /// <summary>
2112 
2113         /// 执行指定数据库事务的命令,指定参数值,返回结果集中的第一行第一列.
2114 
2115         /// </summary>
2116 
2117         /// <remarks>
2118 
2119         /// 此方法不提供访问存储过程输出参数和返回值参数.
2120 
2121         /// 
2122 
2123         /// 示例:  
2124 
2125         ///  int orderCount = (int)ExecuteScalar(trans, "GetOrderCount", 24, 36);
2126 
2127         /// </remarks>
2128 
2129         /// <param>一个有效的连接事务</param>
2130 
2131         /// <param>存储过程名称</param>
2132 
2133         /// <param>分配给存储过程输入参数的对象数组</param>
2134 
2135         /// <returns>返回结果集中的第一行第一列</returns>
2136 
2137         public static object ExecuteScalar(SqlTransaction transaction, string spName, params object[] parameterValues)
2138         {
2139 
2140             if (transaction == null) throw new ArgumentNullException("transaction");
2141 
2142             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
2143 
2144             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2145 
2146             // 如果有参数值
2147 
2148             if ((parameterValues != null) && (parameterValues.Length > 0))
2149             {
2150 
2151                 // PPull the parameters for this stored procedure from the parameter cache ()
2152 
2153                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
2154 
2155                 // 给存储过程参数赋值
2156 
2157                 AssignParameterValues(commandParameters, parameterValues);
2158 
2159                 // 调用重载方法
2160 
2161                 return ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters);
2162 
2163             }
2164 
2165             else
2166             {
2167 
2168                 // 没有参数值
2169 
2170                 return ExecuteScalar(transaction, CommandType.StoredProcedure, spName);
2171 
2172             }
2173 
2174         }
2175 
2176         #endregion ExecuteScalar
2177 
2178 
2179 
2180         #region ExecuteXmlReader XML阅读器
2181 
2182         /// <summary>
2183 
2184         /// 执行指定数据库连接对象的SqlCommand命令,并产生一个XmlReader对象做为结果集返回.
2185 
2186         /// </summary>
2187 
2188         /// <remarks>
2189 
2190         /// 示例:  
2191 
2192         ///  XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders");
2193 
2194         /// </remarks>
2195 
2196         /// <param>一个有效的数据库连接对象</param>
2197 
2198         /// <param>命令类型 (存储过程,命令文本或其它)</param>
2199 
2200         /// <param>存储过程名称或T-SQL语句 using "FOR XML AUTO"</param>
2201 
2202         /// <returns>返回XmlReader结果集对象.</returns>
2203 
2204         public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText)
2205         {
2206 
2207             // 执行参数为空的方法
2208 
2209             return ExecuteXmlReader(connection, commandType, commandText, (SqlParameter[])null);
2210 
2211         }
2212 
2213 
2214 
2215         /// <summary>
2216 
2217         /// 执行指定数据库连接对象的SqlCommand命令,并产生一个XmlReader对象做为结果集返回,指定参数.
2218 
2219         /// </summary>
2220 
2221         /// <remarks>
2222 
2223         /// 示例:  
2224 
2225         ///  XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
2226 
2227         /// </remarks>
2228 
2229         /// <param>一个有效的数据库连接对象</param>
2230 
2231         /// <param>命令类型 (存储过程,命令文本或其它)</param>
2232 
2233         /// <param>存储过程名称或T-SQL语句 using "FOR XML AUTO"</param>
2234 
2235         /// <param>分配给命令的SqlParamter参数数组</param>
2236 
2237         /// <returns>返回XmlReader结果集对象.</returns>
2238 
2239         public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
2240         {
2241 
2242             if (connection == null) throw new ArgumentNullException("connection");
2243 
2244             bool mustCloseConnection = false;
2245 
2246             // 创建SqlCommand命令,并进行预处理
2247 
2248             SqlCommand cmd = new SqlCommand();
2249 
2250             try
2251             {
2252 
2253                 PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
2254 
2255 
2256 
2257                 // 执行命令
2258 
2259                 XmlReader retval = cmd.ExecuteXmlReader();
2260 
2261 
2262 
2263                 // 清除参数,以便再次使用.
2264 
2265                 cmd.Parameters.Clear();
2266 
2267                 return retval;
2268 
2269             }
2270 
2271             catch
2272             {
2273 
2274                 if (mustCloseConnection)
2275 
2276                     connection.Close();
2277 
2278                 throw;
2279 
2280             }
2281 
2282         }
2283 
2284 
2285 
2286         /// <summary>
2287 
2288         /// 执行指定数据库连接对象的SqlCommand命令,并产生一个XmlReader对象做为结果集返回,指定参数值.
2289 
2290         /// </summary>
2291 
2292         /// <remarks>
2293 
2294         /// 此方法不提供访问存储过程输出参数和返回值参数.
2295 
2296         /// 
2297 
2298         /// 示例:  
2299 
2300         ///  XmlReader r = ExecuteXmlReader(conn, "GetOrders", 24, 36);
2301 
2302         /// </remarks>
2303 
2304         /// <param>一个有效的数据库连接对象</param>
2305 
2306         /// <param>存储过程名称 using "FOR XML AUTO"</param>
2307 
2308         /// <param>分配给存储过程输入参数的对象数组</param>
2309 
2310         /// <returns>返回XmlReader结果集对象.</returns>
2311 
2312         public static XmlReader ExecuteXmlReader(SqlConnection connection, string spName, params object[] parameterValues)
2313         {
2314 
2315             if (connection == null) throw new ArgumentNullException("connection");
2316 
2317             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2318 
2319             // 如果有参数值
2320 
2321             if ((parameterValues != null) && (parameterValues.Length > 0))
2322             {
2323 
2324                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
2325 
2326                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
2327 
2328                 // 给存储过程参数赋值
2329 
2330                 AssignParameterValues(commandParameters, parameterValues);
2331 
2332                 // 调用重载方法
2333 
2334                 return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters);
2335 
2336             }
2337 
2338             else
2339             {
2340 
2341                 // 没有参数值
2342 
2343                 return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName);
2344 
2345             }
2346 
2347         }
2348 
2349 
2350 
2351         /// <summary>
2352 
2353         /// 执行指定数据库事务的SqlCommand命令,并产生一个XmlReader对象做为结果集返回.
2354 
2355         /// </summary>
2356 
2357         /// <remarks>
2358 
2359         /// 示例:  
2360 
2361         ///  XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders");
2362 
2363         /// </remarks>
2364 
2365         /// <param>一个有效的连接事务</param>
2366 
2367         /// <param>命令类型 (存储过程,命令文本或其它)</param>
2368 
2369         /// <param>存储过程名称或T-SQL语句 using "FOR XML AUTO"</param>
2370 
2371         /// <returns>返回XmlReader结果集对象.</returns>
2372 
2373         public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText)
2374         {
2375 
2376             // 执行参数为空的方法
2377 
2378             return ExecuteXmlReader(transaction, commandType, commandText, (SqlParameter[])null);
2379 
2380         }
2381 
2382 
2383 
2384         /// <summary>
2385 
2386         /// 执行指定数据库事务的SqlCommand命令,并产生一个XmlReader对象做为结果集返回,指定参数.
2387 
2388         /// </summary>
2389 
2390         /// <remarks>
2391 
2392         /// 示例:  
2393 
2394         ///  XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
2395 
2396         /// </remarks>
2397 
2398         /// <param>一个有效的连接事务</param>
2399 
2400         /// <param>命令类型 (存储过程,命令文本或其它)</param>
2401 
2402         /// <param>存储过程名称或T-SQL语句 using "FOR XML AUTO"</param>
2403 
2404         /// <param>分配给命令的SqlParamter参数数组</param>
2405 
2406         /// <returns>返回XmlReader结果集对象.</returns>
2407 
2408         public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
2409         {
2410 
2411             if (transaction == null) throw new ArgumentNullException("transaction");
2412 
2413             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
2414 
2415             // 创建SqlCommand命令,并进行预处理
2416 
2417             SqlCommand cmd = new SqlCommand();
2418 
2419             bool mustCloseConnection = false;
2420 
2421             PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
2422 
2423 
2424 
2425             // 执行命令
2426 
2427             XmlReader retval = cmd.ExecuteXmlReader();
2428 
2429 
2430 
2431             // 清除参数,以便再次使用.
2432 
2433             cmd.Parameters.Clear();
2434 
2435             return retval;
2436 
2437         }
2438 
2439 
2440 
2441         /// <summary>
2442 
2443         /// 执行指定数据库事务的SqlCommand命令,并产生一个XmlReader对象做为结果集返回,指定参数值.
2444 
2445         /// </summary>
2446 
2447         /// <remarks>
2448 
2449         /// 此方法不提供访问存储过程输出参数和返回值参数.
2450 
2451         /// 
2452 
2453         /// 示例:  
2454 
2455         ///  XmlReader r = ExecuteXmlReader(trans, "GetOrders", 24, 36);
2456 
2457         /// </remarks>
2458 
2459         /// <param>一个有效的连接事务</param>
2460 
2461         /// <param>存储过程名称</param>
2462 
2463         /// <param>分配给存储过程输入参数的对象数组</param>
2464 
2465         /// <returns>返回一个包含结果集的DataSet.</returns>
2466 
2467         public static XmlReader ExecuteXmlReader(SqlTransaction transaction, string spName, params object[] parameterValues)
2468         {
2469 
2470             if (transaction == null) throw new ArgumentNullException("transaction");
2471 
2472             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
2473 
2474             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2475 
2476             // 如果有参数值
2477 
2478             if ((parameterValues != null) && (parameterValues.Length > 0))
2479             {
2480 
2481                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
2482 
2483                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
2484 
2485                 // 给存储过程参数赋值
2486 
2487                 AssignParameterValues(commandParameters, parameterValues);
2488 
2489                 // 调用重载方法
2490 
2491                 return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
2492 
2493             }
2494 
2495             else
2496             {
2497 
2498                 // 没有参数值
2499 
2500                 return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName);
2501 
2502             }
2503 
2504         }
2505 
2506         #endregion ExecuteXmlReader 阅读器结束
2507 
2508 
2509 
2510         #region FillDataset 填充数据集
2511 
2512         /// <summary>
2513 
2514         /// 执行指定数据库连接字符串的命令,映射数据表并填充数据集.
2515 
2516         /// </summary>
2517 
2518         /// <remarks>
2519 
2520         /// 示例:  
2521 
2522         ///  FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
2523 
2524         /// </remarks>
2525 
2526         /// <param>一个有效的数据库连接字符串</param>
2527 
2528         /// <param>命令类型 (存储过程,命令文本或其它)</param>
2529 
2530         /// <param>存储过程名称或T-SQL语句</param>
2531 
2532         /// <param>要填充结果集的DataSet实例</param>
2533 
2534         /// <param>表映射的数据表数组
2535 
2536         /// 用户定义的表名 (可有是实际的表名.)</param>
2537 
2538         public static void FillDataset(string connectionString, CommandType commandType, string commandText, DataSet dataSet, string[] tableNames)
2539         {
2540 
2541             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
2542 
2543             if (dataSet == null) throw new ArgumentNullException("dataSet");
2544 
2545 
2546 
2547             // 创建并打开数据库连接对象,操作完成释放对象.
2548 
2549             using (SqlConnection connection = new SqlConnection(connectionString))
2550             {
2551 
2552                 connection.Open();
2553 
2554                 // 调用指定数据库连接字符串重载方法.
2555 
2556                 FillDataset(connection, commandType, commandText, dataSet, tableNames);
2557 
2558             }
2559 
2560         }
2561 
2562 
2563 
2564         /// <summary>
2565 
2566         /// 执行指定数据库连接字符串的命令,映射数据表并填充数据集.指定命令参数.
2567 
2568         /// </summary>
2569 
2570         /// <remarks>
2571 
2572         /// 示例:  
2573 
2574         ///  FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
2575 
2576         /// </remarks>
2577 
2578         /// <param>一个有效的数据库连接字符串</param>
2579 
2580         /// <param>命令类型 (存储过程,命令文本或其它)</param>
2581 
2582         /// <param>存储过程名称或T-SQL语句</param>
2583 
2584         /// <param>分配给命令的SqlParamter参数数组</param>
2585 
2586         /// <param>要填充结果集的DataSet实例</param>
2587 
2588         /// <param>表映射的数据表数组
2589 
2590         /// 用户定义的表名 (可有是实际的表名.)
2591 
2592         /// </param>
2593 
2594         public static void FillDataset(string connectionString, CommandType commandType,
2595 
2596             string commandText, DataSet dataSet, string[] tableNames,
2597 
2598             params SqlParameter[] commandParameters)
2599         {
2600 
2601             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
2602 
2603             if (dataSet == null) throw new ArgumentNullException("dataSet");
2604 
2605             // 创建并打开数据库连接对象,操作完成释放对象.
2606 
2607             using (SqlConnection connection = new SqlConnection(connectionString))
2608             {
2609 
2610                 connection.Open();
2611 
2612                 // 调用指定数据库连接字符串重载方法.
2613 
2614                 FillDataset(connection, commandType, commandText, dataSet, tableNames, commandParameters);
2615 
2616             }
2617 
2618         }
2619 
2620 
2621 
2622         /// <summary>
2623 
2624         /// 执行指定数据库连接字符串的命令,映射数据表并填充数据集,指定存储过程参数值.
2625 
2626         /// </summary>
2627 
2628         /// <remarks>
2629 
2630         /// 此方法不提供访问存储过程输出参数和返回值参数.
2631 
2632         /// 
2633 
2634         /// 示例:  
2635 
2636         ///  FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, 24);
2637 
2638         /// </remarks>
2639 
2640         /// <param>一个有效的数据库连接字符串</param>
2641 
2642         /// <param>存储过程名称</param>
2643 
2644         /// <param>要填充结果集的DataSet实例</param>
2645 
2646         /// <param>表映射的数据表数组
2647 
2648         /// 用户定义的表名 (可有是实际的表名.)
2649 
2650         /// </param>    
2651 
2652         /// <param>分配给存储过程输入参数的对象数组</param>
2653 
2654         public static void FillDataset(string connectionString, string spName,
2655 
2656             DataSet dataSet, string[] tableNames,
2657 
2658             params object[] parameterValues)
2659         {
2660 
2661             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
2662 
2663             if (dataSet == null) throw new ArgumentNullException("dataSet");
2664 
2665             // 创建并打开数据库连接对象,操作完成释放对象.
2666 
2667             using (SqlConnection connection = new SqlConnection(connectionString))
2668             {
2669 
2670                 connection.Open();
2671 
2672                 // 调用指定数据库连接字符串重载方法.
2673 
2674                 FillDataset(connection, spName, dataSet, tableNames, parameterValues);
2675 
2676             }
2677 
2678         }
2679 
2680 
2681 
2682         /// <summary>
2683 
2684         /// 执行指定数据库连接对象的命令,映射数据表并填充数据集.
2685 
2686         /// </summary>
2687 
2688         /// <remarks>
2689 
2690         /// 示例:  
2691 
2692         ///  FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
2693 
2694         /// </remarks>
2695 
2696         /// <param>一个有效的数据库连接对象</param>
2697 
2698         /// <param>命令类型 (存储过程,命令文本或其它)</param>
2699 
2700         /// <param>存储过程名称或T-SQL语句</param>
2701 
2702         /// <param>要填充结果集的DataSet实例</param>
2703 
2704         /// <param>表映射的数据表数组
2705 
2706         /// 用户定义的表名 (可有是实际的表名.)
2707 
2708         /// </param>    
2709 
2710         public static void FillDataset(SqlConnection connection, CommandType commandType,
2711 
2712             string commandText, DataSet dataSet, string[] tableNames)
2713         {
2714 
2715             FillDataset(connection, commandType, commandText, dataSet, tableNames, null);
2716 
2717         }
2718 
2719 
2720 
2721         /// <summary>
2722 
2723         /// 执行指定数据库连接对象的命令,映射数据表并填充数据集,指定参数.
2724 
2725         /// </summary>
2726 
2727         /// <remarks>
2728 
2729         /// 示例:  
2730 
2731         ///  FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
2732 
2733         /// </remarks>
2734 
2735         /// <param>一个有效的数据库连接对象</param>
2736 
2737         /// <param>命令类型 (存储过程,命令文本或其它)</param>
2738 
2739         /// <param>存储过程名称或T-SQL语句</param>
2740 
2741         /// <param>要填充结果集的DataSet实例</param>
2742 
2743         /// <param>表映射的数据表数组
2744 
2745         /// 用户定义的表名 (可有是实际的表名.)
2746 
2747         /// </param>
2748 
2749         /// <param>分配给命令的SqlParamter参数数组</param>
2750 
2751         public static void FillDataset(SqlConnection connection, CommandType commandType,
2752 
2753             string commandText, DataSet dataSet, string[] tableNames,
2754 
2755             params SqlParameter[] commandParameters)
2756         {
2757 
2758             FillDataset(connection, null, commandType, commandText, dataSet, tableNames, commandParameters);
2759 
2760         }
2761 
2762 
2763 
2764         /// <summary>
2765 
2766         /// 执行指定数据库连接对象的命令,映射数据表并填充数据集,指定存储过程参数值.
2767 
2768         /// </summary>
2769 
2770         /// <remarks>
2771 
2772         /// 此方法不提供访问存储过程输出参数和返回值参数.
2773 
2774         /// 
2775 
2776         /// 示例:  
2777 
2778         ///  FillDataset(conn, "GetOrders", ds, new string[] {"orders"}, 24, 36);
2779 
2780         /// </remarks>
2781 
2782         /// <param>一个有效的数据库连接对象</param>
2783 
2784         /// <param>存储过程名称</param>
2785 
2786         /// <param>要填充结果集的DataSet实例</param>
2787 
2788         /// <param>表映射的数据表数组
2789 
2790         /// 用户定义的表名 (可有是实际的表名.)
2791 
2792         /// </param>
2793 
2794         /// <param>分配给存储过程输入参数的对象数组</param>
2795 
2796         public static void FillDataset(SqlConnection connection, string spName,
2797 
2798             DataSet dataSet, string[] tableNames,
2799 
2800             params object[] parameterValues)
2801         {
2802 
2803             if (connection == null) throw new ArgumentNullException("connection");
2804 
2805             if (dataSet == null) throw new ArgumentNullException("dataSet");
2806 
2807             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2808 
2809             // 如果有参数值
2810 
2811             if ((parameterValues != null) && (parameterValues.Length > 0))
2812             {
2813 
2814                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
2815 
2816                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
2817 
2818                 // 给存储过程参数赋值
2819 
2820                 AssignParameterValues(commandParameters, parameterValues);
2821 
2822                 // 调用重载方法
2823 
2824                 FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames, commandParameters);
2825 
2826             }
2827 
2828             else
2829             {
2830 
2831                 // 没有参数值
2832 
2833                 FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames);
2834 
2835             }
2836 
2837         }
2838 
2839 
2840 
2841         /// <summary>
2842 
2843         /// 执行指定数据库事务的命令,映射数据表并填充数据集.
2844 
2845         /// </summary>
2846 
2847         /// <remarks>
2848 
2849         /// 示例:  
2850 
2851         ///  FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
2852 
2853         /// </remarks>
2854 
2855         /// <param>一个有效的连接事务</param>
2856 
2857         /// <param>命令类型 (存储过程,命令文本或其它)</param>
2858 
2859         /// <param>存储过程名称或T-SQL语句</param>
2860 
2861         /// <param>要填充结果集的DataSet实例</param>
2862 
2863         /// <param>表映射的数据表数组
2864 
2865         /// 用户定义的表名 (可有是实际的表名.)
2866 
2867         /// </param>
2868 
2869         public static void FillDataset(SqlTransaction transaction, CommandType commandType,
2870 
2871             string commandText,
2872 
2873             DataSet dataSet, string[] tableNames)
2874         {
2875 
2876             FillDataset(transaction, commandType, commandText, dataSet, tableNames, null);
2877 
2878         }
2879 
2880 
2881 
2882         /// <summary>
2883 
2884         /// 执行指定数据库事务的命令,映射数据表并填充数据集,指定参数.
2885 
2886         /// </summary>
2887 
2888         /// <remarks>
2889 
2890         /// 示例:  
2891 
2892         ///  FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
2893 
2894         /// </remarks>
2895 
2896         /// <param>一个有效的连接事务</param>
2897 
2898         /// <param>命令类型 (存储过程,命令文本或其它)</param>
2899 
2900         /// <param>存储过程名称或T-SQL语句</param>
2901 
2902         /// <param>要填充结果集的DataSet实例</param>
2903 
2904         /// <param>表映射的数据表数组
2905 
2906         /// 用户定义的表名 (可有是实际的表名.)
2907 
2908         /// </param>
2909 
2910         /// <param>分配给命令的SqlParamter参数数组</param>
2911 
2912         public static void FillDataset(SqlTransaction transaction, CommandType commandType,
2913 
2914             string commandText, DataSet dataSet, string[] tableNames,
2915 
2916             params SqlParameter[] commandParameters)
2917         {
2918 
2919             FillDataset(transaction.Connection, transaction, commandType, commandText, dataSet, tableNames, commandParameters);
2920 
2921         }
2922 
2923 
2924 
2925         /// <summary>
2926 
2927         /// 执行指定数据库事务的命令,映射数据表并填充数据集,指定存储过程参数值.
2928 
2929         /// </summary>
2930 
2931         /// <remarks>
2932 
2933         /// 此方法不提供访问存储过程输出参数和返回值参数.
2934 
2935         /// 
2936 
2937         /// 示例:  
2938 
2939         ///  FillDataset(trans, "GetOrders", ds, new string[]{"orders"}, 24, 36);
2940 
2941         /// </remarks>
2942 
2943         /// <param>一个有效的连接事务</param>
2944 
2945         /// <param>存储过程名称</param>
2946 
2947         /// <param>要填充结果集的DataSet实例</param>
2948 
2949         /// <param>表映射的数据表数组
2950 
2951         /// 用户定义的表名 (可有是实际的表名.)
2952 
2953         /// </param>
2954 
2955         /// <param>分配给存储过程输入参数的对象数组</param>
2956 
2957         public static void FillDataset(SqlTransaction transaction, string spName,
2958 
2959             DataSet dataSet, string[] tableNames,
2960 
2961             params object[] parameterValues)
2962         {
2963 
2964             if (transaction == null) throw new ArgumentNullException("transaction");
2965 
2966             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
2967 
2968             if (dataSet == null) throw new ArgumentNullException("dataSet");
2969 
2970             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2971 
2972             // 如果有参数值
2973 
2974             if ((parameterValues != null) && (parameterValues.Length > 0))
2975             {
2976 
2977                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
2978 
2979                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
2980 
2981                 // 给存储过程参数赋值
2982 
2983                 AssignParameterValues(commandParameters, parameterValues);
2984 
2985                 // 调用重载方法
2986 
2987                 FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames, commandParameters);
2988 
2989             }
2990 
2991             else
2992             {
2993 
2994                 // 没有参数值
2995 
2996                 FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames);
2997 
2998             }
2999 
3000         }
3001 
3002 
3003 
3004         /// <summary>
3005 
3006         /// [私有方法][内部调用]执行指定数据库连接对象/事务的命令,映射数据表并填充数据集,DataSet/TableNames/SqlParameters.
3007 
3008         /// </summary>
3009 
3010         /// <remarks>
3011 
3012         /// 示例:  
3013 
3014         ///  FillDataset(conn, trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
3015 
3016         /// </remarks>
3017 
3018         /// <param>一个有效的数据库连接对象</param>
3019 
3020         /// <param>一个有效的连接事务</param>
3021 
3022         /// <param>命令类型 (存储过程,命令文本或其它)</param>
3023 
3024         /// <param>存储过程名称或T-SQL语句</param>
3025 
3026         /// <param>要填充结果集的DataSet实例</param>
3027 
3028         /// <param>表映射的数据表数组
3029 
3030         /// 用户定义的表名 (可有是实际的表名.)
3031 
3032         /// </param>
3033 
3034         /// <param>分配给命令的SqlParamter参数数组</param>
3035 
3036         private static void FillDataset(SqlConnection connection, SqlTransaction transaction, CommandType commandType,
3037 
3038             string commandText, DataSet dataSet, string[] tableNames,
3039 
3040             params SqlParameter[] commandParameters)
3041         {
3042 
3043             if (connection == null) throw new ArgumentNullException("connection");
3044 
3045             if (dataSet == null) throw new ArgumentNullException("dataSet");
3046 
3047             // 创建SqlCommand命令,并进行预处理
3048 
3049             SqlCommand command = new SqlCommand();
3050 
3051             bool mustCloseConnection = false;
3052 
3053             PrepareCommand(command, connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
3054 
3055 
3056 
3057             // 执行命令
3058 
3059             using (SqlDataAdapter dataAdapter = new SqlDataAdapter(command))
3060             {
3061 
3062 
3063 
3064                 // 追加表映射
3065 
3066                 if (tableNames != null && tableNames.Length > 0)
3067                 {
3068 
3069                     string tableName = "Table";
3070 
3071                     for (int index = 0; index < tableNames.Length; index++)
3072                     {
3073 
3074                         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");
3075 
3076                         dataAdapter.TableMappings.Add(tableName, tableNames[index]);
3077 
3078                         tableName += (index + 1).ToString();
3079 
3080                     }
3081 
3082                 }
3083 
3084 
3085 
3086                 // 填充数据集使用默认表名称
3087 
3088                 dataAdapter.Fill(dataSet);
3089 
3090                 // 清除参数,以便再次使用.
3091 
3092                 command.Parameters.Clear();
3093 
3094             }
3095 
3096             if (mustCloseConnection)
3097 
3098                 connection.Close();
3099 
3100         }
3101 
3102         #endregion
3103 
3104 
3105 
3106         #region UpdateDataset 更新数据集
3107 
3108         /// <summary>
3109 
3110         /// 执行数据集更新到数据库,指定inserted, updated, or deleted命令.
3111 
3112         /// </summary>
3113 
3114         /// <remarks>
3115 
3116         /// 示例:  
3117 
3118         ///  UpdateDataset(conn, insertCommand, deleteCommand, updateCommand, dataSet, "Order");
3119 
3120         /// </remarks>
3121 
3122         /// <param>[追加记录]一个有效的T-SQL语句或存储过程</param>
3123 
3124         /// <param>[删除记录]一个有效的T-SQL语句或存储过程</param>
3125 
3126         /// <param>[更新记录]一个有效的T-SQL语句或存储过程</param>
3127 
3128         /// <param>要更新到数据库的DataSet</param>
3129 
3130         /// <param>要更新到数据库的DataTable</param>
3131 
3132         public static void UpdateDataset(SqlCommand insertCommand, SqlCommand deleteCommand, SqlCommand updateCommand, DataSet dataSet, string tableName)
3133         {
3134 
3135             if (insertCommand == null) throw new ArgumentNullException("insertCommand");
3136 
3137             if (deleteCommand == null) throw new ArgumentNullException("deleteCommand");
3138 
3139             if (updateCommand == null) throw new ArgumentNullException("updateCommand");
3140 
3141             if (tableName == null || tableName.Length == 0) throw new ArgumentNullException("tableName");
3142 
3143             // 创建SqlDataAdapter,当操作完成后释放.
3144 
3145             using (SqlDataAdapter dataAdapter = new SqlDataAdapter())
3146             {
3147 
3148                 // 设置数据适配器命令
3149 
3150                 dataAdapter.UpdateCommand = updateCommand;
3151 
3152                 dataAdapter.InsertCommand = insertCommand;
3153 
3154                 dataAdapter.DeleteCommand = deleteCommand;
3155 
3156                 // 更新数据集改变到数据库
3157 
3158                 dataAdapter.Update(dataSet, tableName);
3159 
3160                 // 提交所有改变到数据集.
3161 
3162                 dataSet.AcceptChanges();
3163 
3164             }
3165 
3166         }
3167 
3168         #endregion
3169 
3170 
3171 
3172         #region CreateCommand 创建一条SqlCommand命令
3173 
3174         /// <summary>
3175 
3176         /// 创建SqlCommand命令,指定数据库连接对象,存储过程名和参数.
3177 
3178         /// </summary>
3179 
3180         /// <remarks>
3181 
3182         /// 示例:  
3183 
3184         ///  SqlCommand command = CreateCommand(conn, "AddCustomer", "CustomerID", "CustomerName");
3185 
3186         /// </remarks>
3187 
3188         /// <param>一个有效的数据库连接对象</param>
3189 
3190         /// <param>存储过程名称</param>
3191 
3192         /// <param>源表的列名称数组</param>
3193 
3194         /// <returns>返回SqlCommand命令</returns>
3195 
3196         public static SqlCommand CreateCommand(SqlConnection connection, string spName, params string[] sourceColumns)
3197         {
3198 
3199             if (connection == null) throw new ArgumentNullException("connection");
3200 
3201             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
3202 
3203             // 创建命令
3204 
3205             SqlCommand cmd = new SqlCommand(spName, connection);
3206 
3207             cmd.CommandType = CommandType.StoredProcedure;
3208 
3209             // 如果有参数值
3210 
3211             if ((sourceColumns != null) && (sourceColumns.Length > 0))
3212             {
3213 
3214                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
3215 
3216                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
3217 
3218                 // 将源表的列到映射到DataSet命令中.
3219 
3220                 for (int index = 0; index < sourceColumns.Length; index++)
3221 
3222                     commandParameters[index].SourceColumn = sourceColumns[index];
3223 
3224                 // Attach the discovered parameters to the SqlCommand object
3225 
3226                 AttachParameters(cmd, commandParameters);
3227 
3228             }
3229 
3230             return cmd;
3231 
3232         }
3233 
3234         #endregion
3235 
3236 
3237 
3238         #region ExecuteNonQueryTypedParams 类型化参数(DataRow)
3239 
3240         /// <summary>
3241 
3242         /// 执行指定连接数据库连接字符串的存储过程,使用DataRow做为参数值,返回受影响的行数.
3243 
3244         /// </summary>
3245 
3246         /// <param>一个有效的数据库连接字符串</param>
3247 
3248         /// <param>存储过程名称</param>
3249 
3250         /// <param>使用DataRow作为参数值</param>
3251 
3252         /// <returns>返回影响的行数</returns>
3253 
3254         public static int ExecuteNonQueryTypedParams(String connectionString, String spName, DataRow dataRow)
3255         {
3256 
3257             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
3258 
3259             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
3260 
3261 
3262 
3263             // 如果row有值,存储过程必须初始化.
3264 
3265             if (dataRow != null && dataRow.ItemArray.Length > 0)
3266             {
3267 
3268                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
3269 
3270                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
3271 
3272 
3273 
3274                 // 分配参数值
3275 
3276                 AssignParameterValues(commandParameters, dataRow);
3277 
3278 
3279 
3280                 return SqlHelper.ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);
3281 
3282             }
3283 
3284             else
3285             {
3286 
3287                 return SqlHelper.ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);
3288 
3289             }
3290 
3291         }
3292 
3293 
3294 
3295         /// <summary>
3296 
3297         /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回受影响的行数.
3298 
3299         /// </summary>
3300 
3301         /// <param>一个有效的数据库连接对象</param>
3302 
3303         /// <param>存储过程名称</param>
3304 
3305         /// <param>使用DataRow作为参数值</param>
3306 
3307         /// <returns>返回影响的行数</returns>
3308 
3309         public static int ExecuteNonQueryTypedParams(SqlConnection connection, String spName, DataRow dataRow)
3310         {
3311 
3312             if (connection == null) throw new ArgumentNullException("connection");
3313 
3314             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
3315 
3316             // 如果row有值,存储过程必须初始化.
3317 
3318             if (dataRow != null && dataRow.ItemArray.Length > 0)
3319             {
3320 
3321                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
3322 
3323                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
3324 
3325 
3326 
3327                 // 分配参数值
3328 
3329                 AssignParameterValues(commandParameters, dataRow);
3330 
3331 
3332 
3333                 return SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);
3334 
3335             }
3336 
3337             else
3338             {
3339 
3340                 return SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);
3341 
3342             }
3343 
3344         }
3345 
3346 
3347 
3348         /// <summary>
3349 
3350         /// 执行指定连接数据库事物的存储过程,使用DataRow做为参数值,返回受影响的行数.
3351 
3352         /// </summary>
3353 
3354         /// <param>一个有效的连接事务 object</param>
3355 
3356         /// <param>存储过程名称</param>
3357 
3358         /// <param>使用DataRow作为参数值</param>
3359 
3360         /// <returns>返回影响的行数</returns>
3361 
3362         public static int ExecuteNonQueryTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
3363         {
3364 
3365             if (transaction == null) throw new ArgumentNullException("transaction");
3366 
3367             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
3368 
3369             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
3370 
3371             // Sf the row has values, the store procedure parameters must be initialized
3372 
3373             if (dataRow != null && dataRow.ItemArray.Length > 0)
3374             {
3375 
3376                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
3377 
3378                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
3379 
3380 
3381 
3382                 // 分配参数值
3383 
3384                 AssignParameterValues(commandParameters, dataRow);
3385 
3386 
3387 
3388                 return SqlHelper.ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters);
3389 
3390             }
3391 
3392             else
3393             {
3394 
3395                 return SqlHelper.ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);
3396 
3397             }
3398 
3399         }
3400 
3401         #endregion
3402 
3403 
3404 
3405         #region ExecuteDatasetTypedParams 类型化参数(DataRow)
3406 
3407         /// <summary>
3408 
3409         /// 执行指定连接数据库连接字符串的存储过程,使用DataRow做为参数值,返回DataSet.
3410 
3411         /// </summary>
3412 
3413         /// <param>一个有效的数据库连接字符串</param>
3414 
3415         /// <param>存储过程名称</param>
3416 
3417         /// <param>使用DataRow作为参数值</param>
3418 
3419         /// <returns>返回一个包含结果集的DataSet.</returns>
3420 
3421         public static DataSet ExecuteDatasetTypedParams(string connectionString, String spName, DataRow dataRow)
3422         {
3423 
3424             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
3425 
3426             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
3427 
3428             //如果row有值,存储过程必须初始化.
3429 
3430             if (dataRow != null && dataRow.ItemArray.Length > 0)
3431             {
3432 
3433                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
3434 
3435                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
3436 
3437 
3438 
3439                 // 分配参数值
3440 
3441                 AssignParameterValues(commandParameters, dataRow);
3442 
3443 
3444 
3445                 return SqlHelper.ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);
3446 
3447             }
3448 
3449             else
3450             {
3451 
3452                 return SqlHelper.ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);
3453 
3454             }
3455 
3456         }
3457 
3458 
3459 
3460         /// <summary>
3461 
3462         /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回DataSet.
3463 
3464         /// </summary>
3465 
3466         /// <param>一个有效的数据库连接对象</param>
3467 
3468         /// <param>存储过程名称</param>
3469 
3470         /// <param>使用DataRow作为参数值</param>
3471 
3472         /// <returns>返回一个包含结果集的DataSet.</returns>
3473 
3474         /// 
3475 
3476         public static DataSet ExecuteDatasetTypedParams(SqlConnection connection, String spName, DataRow dataRow)
3477         {
3478 
3479             if (connection == null) throw new ArgumentNullException("connection");
3480 
3481             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
3482 
3483             // 如果row有值,存储过程必须初始化.
3484 
3485             if (dataRow != null && dataRow.ItemArray.Length > 0)
3486             {
3487 
3488                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
3489 
3490                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
3491 
3492 
3493 
3494                 // 分配参数值
3495 
3496                 AssignParameterValues(commandParameters, dataRow);
3497 
3498 
3499 
3500                 return SqlHelper.ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters);
3501 
3502             }
3503 
3504             else
3505             {
3506 
3507                 return SqlHelper.ExecuteDataset(connection, CommandType.StoredProcedure, spName);
3508 
3509             }
3510 
3511         }
3512 
3513 
3514 
3515         /// <summary>
3516 
3517         /// 执行指定连接数据库事务的存储过程,使用DataRow做为参数值,返回DataSet.
3518 
3519         /// </summary>
3520 
3521         /// <param>一个有效的连接事务 object</param>
3522 
3523         /// <param>存储过程名称</param>
3524 
3525         /// <param>使用DataRow作为参数值</param>
3526 
3527         /// <returns>返回一个包含结果集的DataSet.</returns>
3528 
3529         public static DataSet ExecuteDatasetTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
3530         {
3531 
3532             if (transaction == null) throw new ArgumentNullException("transaction");
3533 
3534             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
3535 
3536             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
3537 
3538             // 如果row有值,存储过程必须初始化.
3539 
3540             if (dataRow != null && dataRow.ItemArray.Length > 0)
3541             {
3542 
3543                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
3544 
3545                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
3546 
3547 
3548 
3549                 // 分配参数值
3550 
3551                 AssignParameterValues(commandParameters, dataRow);
3552 
3553 
3554 
3555                 return SqlHelper.ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters);
3556 
3557             }
3558 
3559             else
3560             {
3561 
3562                 return SqlHelper.ExecuteDataset(transaction, CommandType.StoredProcedure, spName);
3563 
3564             }
3565 
3566         }
3567 
3568         #endregion
3569 
3570 
3571 
3572         #region ExecuteReaderTypedParams 类型化参数(DataRow)
3573 
3574         /// <summary>
3575 
3576         /// 执行指定连接数据库连接字符串的存储过程,使用DataRow做为参数值,返回DataReader.
3577 
3578         /// </summary>
3579 
3580         /// <param>一个有效的数据库连接字符串</param>
3581 
3582         /// <param>存储过程名称</param>
3583 
3584         /// <param>使用DataRow作为参数值</param>
3585 
3586         /// <returns>返回包含结果集的SqlDataReader</returns>
3587 
3588         public static SqlDataReader ExecuteReaderTypedParams(String connectionString, String spName, DataRow dataRow)
3589         {
3590 
3591             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
3592 
3593             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
3594 
3595 
3596 
3597             // 如果row有值,存储过程必须初始化.
3598 
3599             if (dataRow != null && dataRow.ItemArray.Length > 0)
3600             {
3601 
3602                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
3603 
3604                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
3605 
3606 
3607 
3608                 // 分配参数值
3609 
3610                 AssignParameterValues(commandParameters, dataRow);
3611 
3612 
3613 
3614                 return SqlHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters);
3615 
3616             }
3617 
3618             else
3619             {
3620 
3621                 return SqlHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, spName);
3622 
3623             }
3624 
3625         }
3626 
3627 
3628 
3629         /// <summary>
3630 
3631         /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回DataReader.
3632 
3633         /// </summary>
3634 
3635         /// <param>一个有效的数据库连接对象</param>
3636 
3637         /// <param>存储过程名称</param>
3638 
3639         /// <param>使用DataRow作为参数值</param>
3640 
3641         /// <returns>返回包含结果集的SqlDataReader</returns>
3642 
3643         public static SqlDataReader ExecuteReaderTypedParams(SqlConnection connection, String spName, DataRow dataRow)
3644         {
3645 
3646             if (connection == null) throw new ArgumentNullException("connection");
3647 
3648             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
3649 
3650             // 如果row有值,存储过程必须初始化.
3651 
3652             if (dataRow != null && dataRow.ItemArray.Length > 0)
3653             {
3654 
3655                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
3656 
3657                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
3658 
3659 
3660 
3661                 // 分配参数值
3662 
3663                 AssignParameterValues(commandParameters, dataRow);
3664 
3665 
3666 
3667                 return SqlHelper.ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters);
3668 
3669             }
3670 
3671             else
3672             {
3673 
3674                 return SqlHelper.ExecuteReader(connection, CommandType.StoredProcedure, spName);
3675 
3676             }
3677 
3678         }
3679 
3680 
3681 
3682         /// <summary>
3683 
3684         /// 执行指定连接数据库事物的存储过程,使用DataRow做为参数值,返回DataReader.
3685 
3686         /// </summary>
3687 
3688         /// <param>一个有效的连接事务 object</param>
3689 
3690         /// <param>存储过程名称</param>
3691 
3692         /// <param>使用DataRow作为参数值</param>
3693 
3694         /// <returns>返回包含结果集的SqlDataReader</returns>
3695 
3696         public static SqlDataReader ExecuteReaderTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
3697         {
3698 
3699             if (transaction == null) throw new ArgumentNullException("transaction");
3700 
3701             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
3702 
3703             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
3704 
3705             // 如果row有值,存储过程必须初始化.
3706 
3707             if (dataRow != null && dataRow.ItemArray.Length > 0)
3708             {
3709 
3710                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
3711 
3712                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
3713 
3714 
3715 
3716                 // 分配参数值
3717 
3718                 AssignParameterValues(commandParameters, dataRow);
3719 
3720 
3721 
3722                 return SqlHelper.ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
3723 
3724             }
3725 
3726             else
3727             {
3728 
3729                 return SqlHelper.ExecuteReader(transaction, CommandType.StoredProcedure, spName);
3730 
3731             }
3732 
3733         }
3734 
3735         #endregion
3736 
3737 
3738 
3739         #region ExecuteScalarTypedParams 类型化参数(DataRow)
3740 
3741         /// <summary>
3742 
3743         /// 执行指定连接数据库连接字符串的存储过程,使用DataRow做为参数值,返回结果集中的第一行第一列.
3744 
3745         /// </summary>
3746 
3747         /// <param>一个有效的数据库连接字符串</param>
3748 
3749         /// <param>存储过程名称</param>
3750 
3751         /// <param>使用DataRow作为参数值</param>
3752 
3753         /// <returns>返回结果集中的第一行第一列</returns>
3754 
3755         public static object ExecuteScalarTypedParams(String connectionString, String spName, DataRow dataRow)
3756         {
3757 
3758             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
3759 
3760             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
3761 
3762 
3763 
3764             // 如果row有值,存储过程必须初始化.
3765 
3766             if (dataRow != null && dataRow.ItemArray.Length > 0)
3767             {
3768 
3769                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
3770 
3771                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
3772 
3773 
3774 
3775                 // 分配参数值
3776 
3777                 AssignParameterValues(commandParameters, dataRow);
3778 
3779 
3780 
3781                 return SqlHelper.ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters);
3782 
3783             }
3784 
3785             else
3786             {
3787 
3788                 return SqlHelper.ExecuteScalar(connectionString, CommandType.StoredProcedure, spName);
3789 
3790             }
3791 
3792         }
3793 
3794 
3795 
3796         /// <summary>
3797 
3798         /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回结果集中的第一行第一列.
3799 
3800         /// </summary>
3801 
3802         /// <param>一个有效的数据库连接对象</param>
3803 
3804         /// <param>存储过程名称</param>
3805 
3806         /// <param>使用DataRow作为参数值</param>
3807 
3808         /// <returns>返回结果集中的第一行第一列</returns>
3809 
3810         public static object ExecuteScalarTypedParams(SqlConnection connection, String spName, DataRow dataRow)
3811         {
3812 
3813             if (connection == null) throw new ArgumentNullException("connection");
3814 
3815             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
3816 
3817             // 如果row有值,存储过程必须初始化.
3818 
3819             if (dataRow != null && dataRow.ItemArray.Length > 0)
3820             {
3821 
3822                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
3823 
3824                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
3825 
3826 
3827 
3828                 // 分配参数值
3829 
3830                 AssignParameterValues(commandParameters, dataRow);
3831 
3832 
3833 
3834                 return SqlHelper.ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters);
3835 
3836             }
3837 
3838             else
3839             {
3840 
3841                 return SqlHelper.ExecuteScalar(connection, CommandType.StoredProcedure, spName);
3842 
3843             }
3844 
3845         }
3846 
3847 
3848 
3849         /// <summary>
3850 
3851         /// 执行指定连接数据库事务的存储过程,使用DataRow做为参数值,返回结果集中的第一行第一列.
3852 
3853         /// </summary>
3854 
3855         /// <param>一个有效的连接事务 object</param>
3856 
3857         /// <param>存储过程名称</param>
3858 
3859         /// <param>使用DataRow作为参数值</param>
3860 
3861         /// <returns>返回结果集中的第一行第一列</returns>
3862 
3863         public static object ExecuteScalarTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
3864         {
3865 
3866             if (transaction == null) throw new ArgumentNullException("transaction");
3867 
3868             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
3869 
3870             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
3871 
3872             // 如果row有值,存储过程必须初始化.
3873 
3874             if (dataRow != null && dataRow.ItemArray.Length > 0)
3875             {
3876 
3877                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
3878 
3879                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
3880 
3881 
3882 
3883                 // 分配参数值
3884 
3885                 AssignParameterValues(commandParameters, dataRow);
3886 
3887 
3888 
3889                 return SqlHelper.ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters);
3890 
3891             }
3892 
3893             else
3894             {
3895 
3896                 return SqlHelper.ExecuteScalar(transaction, CommandType.StoredProcedure, spName);
3897 
3898             }
3899 
3900         }
3901 
3902         #endregion
3903 
3904 
3905 
3906         #region ExecuteXmlReaderTypedParams 类型化参数(DataRow)
3907 
3908         /// <summary>
3909 
3910         /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回XmlReader类型的结果集.
3911 
3912         /// </summary>
3913 
3914         /// <param>一个有效的数据库连接对象</param>
3915 
3916         /// <param>存储过程名称</param>
3917 
3918         /// <param>使用DataRow作为参数值</param>
3919 
3920         /// <returns>返回XmlReader结果集对象.</returns>
3921 
3922         public static XmlReader ExecuteXmlReaderTypedParams(SqlConnection connection, String spName, DataRow dataRow)
3923         {
3924 
3925             if (connection == null) throw new ArgumentNullException("connection");
3926 
3927             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
3928 
3929             // 如果row有值,存储过程必须初始化.
3930 
3931             if (dataRow != null && dataRow.ItemArray.Length > 0)
3932             {
3933 
3934                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
3935 
3936                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
3937 
3938 
3939 
3940                 // 分配参数值
3941 
3942                 AssignParameterValues(commandParameters, dataRow);
3943 
3944 
3945 
3946                 return SqlHelper.ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters);
3947 
3948             }
3949 
3950             else
3951             {
3952 
3953                 return SqlHelper.ExecuteXmlReader(connection, CommandType.StoredProcedure, spName);
3954 
3955             }
3956 
3957         }
3958 
3959 
3960 
3961         /// <summary>
3962 
3963         /// 执行指定连接数据库事务的存储过程,使用DataRow做为参数值,返回XmlReader类型的结果集.
3964 
3965         /// </summary>
3966 
3967         /// <param>一个有效的连接事务 object</param>
3968 
3969         /// <param>存储过程名称</param>
3970 
3971         /// <param>使用DataRow作为参数值</param>
3972 
3973         /// <returns>返回XmlReader结果集对象.</returns>
3974 
3975         public static XmlReader ExecuteXmlReaderTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
3976         {
3977 
3978             if (transaction == null) throw new ArgumentNullException("transaction");
3979 
3980             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
3981 
3982             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
3983 
3984             // 如果row有值,存储过程必须初始化.
3985 
3986             if (dataRow != null && dataRow.ItemArray.Length > 0)
3987             {
3988 
3989                 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
3990 
3991                 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
3992 
3993 
3994 
3995                 // 分配参数值
3996 
3997                 AssignParameterValues(commandParameters, dataRow);
3998 
3999 
4000 
4001                 return SqlHelper.ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
4002 
4003             }
4004 
4005             else
4006             {
4007 
4008                 return SqlHelper.ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName);
4009 
4010             }
4011 
4012         }
4013 
4014         #endregion
4015 
4016     }
4017 
4018 
4019 
4020     /// <summary>
4021 
4022     /// SqlHelperParameterCache提供缓存存储过程参数,并能够在运行时从存储过程中探索参数.
4023 
4024     /// </summary>
4025 
4026     public sealed class SqlHelperParameterCache
4027     {
4028 
4029         #region 私有方法,字段,构造函数
4030 
4031         // 私有构造函数,妨止类被实例化.
4032 
4033         private SqlHelperParameterCache() { }
4034 
4035         // 这个方法要注意
4036 
4037         private static Hashtable paramCache = Hashtable.Synchronized(new Hashtable());
4038 
4039         /// <summary>
4040 
4041         /// 探索运行时的存储过程,返回SqlParameter参数数组.
4042 
4043         /// 初始化参数值为 DBNull.Value.
4044 
4045         /// </summary>
4046 
4047         /// <param>一个有效的数据库连接</param>
4048 
4049         /// <param>存储过程名称</param>
4050 
4051         /// <param>是否包含返回值参数</param>
4052 
4053         /// <returns>返回SqlParameter参数数组</returns>
4054 
4055         private static SqlParameter[] DiscoverSpParameterSet(SqlConnection connection, string spName, bool includeReturnValueParameter)
4056         {
4057 
4058             if (connection == null) throw new ArgumentNullException("connection");
4059 
4060             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
4061 
4062             SqlCommand cmd = new SqlCommand(spName, connection);
4063 
4064             cmd.CommandType = CommandType.StoredProcedure;
4065 
4066             connection.Open();
4067 
4068             // 检索cmd指定的存储过程的参数信息,并填充到cmd的Parameters参数集中.
4069 
4070             SqlCommandBuilder.DeriveParameters(cmd);
4071 
4072             connection.Close();
4073 
4074             // 如果不包含返回值参数,将参数集中的每一个参数删除.
4075 
4076             if (!includeReturnValueParameter)
4077             {
4078 
4079                 cmd.Parameters.RemoveAt(0);
4080 
4081             }
4082 
4083 
4084 
4085             // 创建参数数组
4086 
4087             SqlParameter[] discoveredParameters = new SqlParameter[cmd.Parameters.Count];
4088 
4089             // 将cmd的Parameters参数集复制到discoveredParameters数组.
4090 
4091             cmd.Parameters.CopyTo(discoveredParameters, 0);
4092 
4093             // 初始化参数值为 DBNull.Value.
4094 
4095             foreach (SqlParameter discoveredParameter in discoveredParameters)
4096             {
4097 
4098                 discoveredParameter.Value = DBNull.Value;
4099 
4100             }
4101 
4102             return discoveredParameters;
4103 
4104         }
4105 
4106 
4107 
4108         /// <summary>
4109 
4110         /// SqlParameter参数数组的深层拷贝.
4111 
4112         /// </summary>
4113 
4114         /// <param>原始参数数组</param>
4115 
4116         /// <returns>返回一个同样的参数数组</returns>
4117 
4118         private static SqlParameter[] CloneParameters(SqlParameter[] originalParameters)
4119         {
4120 
4121             SqlParameter[] clonedParameters = new SqlParameter[originalParameters.Length];
4122 
4123             for (int i = 0, j = originalParameters.Length; i < j; i++)
4124             {
4125 
4126                 clonedParameters[i] = (SqlParameter)((ICloneable)originalParameters[i]).Clone();
4127 
4128             }
4129 
4130             return clonedParameters;
4131 
4132         }
4133 
4134         #endregion 私有方法,字段,构造函数结束
4135 
4136 
4137 
4138         #region 缓存方法
4139 
4140         /// <summary>
4141 
4142         /// 追加参数数组到缓存.
4143 
4144         /// </summary>
4145 
4146         /// <param>一个有效的数据库连接字符串</param>
4147 
4148         /// <param>存储过程名或SQL语句</param>
4149 
4150         /// <param>要缓存的参数数组</param>
4151 
4152         public static void CacheParameterSet(string connectionString, string commandText, params SqlParameter[] commandParameters)
4153         {
4154 
4155             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
4156 
4157             if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText");
4158 
4159             string hashKey = connectionString + ":" + commandText;
4160 
4161             paramCache[hashKey] = commandParameters;
4162 
4163         }
4164 
4165 
4166 
4167         /// <summary>
4168 
4169         /// 从缓存中获取参数数组.
4170 
4171         /// </summary>
4172 
4173         /// <param>一个有效的数据库连接字符</param>
4174 
4175         /// <param>存储过程名或SQL语句</param>
4176 
4177         /// <returns>参数数组</returns>
4178 
4179         public static SqlParameter[] GetCachedParameterSet(string connectionString, string commandText)
4180         {
4181 
4182             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
4183 
4184             if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText");
4185 
4186             string hashKey = connectionString + ":" + commandText;
4187 
4188             SqlParameter[] cachedParameters = paramCache[hashKey] as SqlParameter[];
4189 
4190             if (cachedParameters == null)
4191             {
4192 
4193                 return null;
4194 
4195             }
4196 
4197             else
4198             {
4199 
4200                 return CloneParameters(cachedParameters);
4201 
4202             }
4203 
4204         }
4205 
4206         #endregion 缓存方法结束
4207 
4208 
4209 
4210         #region 检索指定的存储过程的参数集
4211 
4212         /// <summary>
4213 
4214         /// 返回指定的存储过程的参数集
4215 
4216         /// </summary>
4217 
4218         /// <remarks>
4219 
4220         /// 这个方法将查询数据库,并将信息存储到缓存.
4221 
4222         /// </remarks>
4223 
4224         /// <param>一个有效的数据库连接字符</param>
4225 
4226         /// <param>存储过程名</param>
4227 
4228         /// <returns>返回SqlParameter参数数组</returns>
4229 
4230         public static SqlParameter[] GetSpParameterSet(string connectionString, string spName)
4231         {
4232 
4233             return GetSpParameterSet(connectionString, spName, false);
4234 
4235         }
4236 
4237 
4238 
4239         /// <summary>
4240 
4241         /// 返回指定的存储过程的参数集
4242 
4243         /// </summary>
4244 
4245         /// <remarks>
4246 
4247         /// 这个方法将查询数据库,并将信息存储到缓存.
4248 
4249         /// </remarks>
4250 
4251         /// <param>一个有效的数据库连接字符.</param>
4252 
4253         /// <param>存储过程名</param>
4254 
4255         /// <param>是否包含返回值参数</param>
4256 
4257         /// <returns>返回SqlParameter参数数组</returns>
4258 
4259         public static SqlParameter[] GetSpParameterSet(string connectionString, string spName, bool includeReturnValueParameter)
4260         {
4261 
4262             if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
4263 
4264             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
4265 
4266             using (SqlConnection connection = new SqlConnection(connectionString))
4267             {
4268 
4269                 return GetSpParameterSetInternal(connection, spName, includeReturnValueParameter);
4270 
4271             }
4272 
4273         }
4274 
4275 
4276 
4277         /// <summary>
4278 
4279         /// [内部]返回指定的存储过程的参数集(使用连接对象).
4280 
4281         /// </summary>
4282 
4283         /// <remarks>
4284 
4285         /// 这个方法将查询数据库,并将信息存储到缓存.
4286 
4287         /// </remarks>
4288 
4289         /// <param>一个有效的数据库连接字符</param>
4290 
4291         /// <param>存储过程名</param>
4292 
4293         /// <returns>返回SqlParameter参数数组</returns>
4294 
4295         internal static SqlParameter[] GetSpParameterSet(SqlConnection connection, string spName)
4296         {
4297 
4298             return GetSpParameterSet(connection, spName, false);
4299 
4300         }
4301 
4302 
4303 
4304         /// <summary>
4305 
4306         /// [内部]返回指定的存储过程的参数集(使用连接对象)
4307 
4308         /// </summary>
4309 
4310         /// <remarks>
4311 
4312         /// 这个方法将查询数据库,并将信息存储到缓存.
4313 
4314         /// </remarks>
4315 
4316         /// <param>一个有效的数据库连接对象</param>
4317 
4318         /// <param>存储过程名</param>
4319 
4320         /// <param>
4321 
4322         /// 是否包含返回值参数
4323 
4324         /// </param>
4325 
4326         /// <returns>返回SqlParameter参数数组</returns>
4327 
4328         internal static SqlParameter[] GetSpParameterSet(SqlConnection connection, string spName, bool includeReturnValueParameter)
4329         {
4330 
4331             if (connection == null) throw new ArgumentNullException("connection");
4332 
4333             using (SqlConnection clonedConnection = (SqlConnection)((ICloneable)connection).Clone())
4334             {
4335 
4336                 return GetSpParameterSetInternal(clonedConnection, spName, includeReturnValueParameter);
4337 
4338             }
4339 
4340         }
4341 
4342 
4343 
4344         /// <summary>
4345 
4346         /// [私有]返回指定的存储过程的参数集(使用连接对象)
4347 
4348         /// </summary>
4349 
4350         /// <param>一个有效的数据库连接对象</param>
4351 
4352         /// <param>存储过程名</param>
4353 
4354         /// <param>是否包含返回值参数</param>
4355 
4356         /// <returns>返回SqlParameter参数数组</returns>
4357 
4358         private static SqlParameter[] GetSpParameterSetInternal(SqlConnection connection, string spName, bool includeReturnValueParameter)
4359         {
4360 
4361             if (connection == null) throw new ArgumentNullException("connection");
4362 
4363             if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
4364 
4365             string hashKey = connection.ConnectionString + ":" + spName + (includeReturnValueParameter ? ":include ReturnValue Parameter" : "");
4366 
4367             SqlParameter[] cachedParameters;
4368 
4369 
4370 
4371             cachedParameters = paramCache[hashKey] as SqlParameter[];
4372 
4373             if (cachedParameters == null)
4374             {
4375 
4376                 SqlParameter[] spParameters = DiscoverSpParameterSet(connection, spName, includeReturnValueParameter);
4377 
4378                 paramCache[hashKey] = spParameters;
4379 
4380                 cachedParameters = spParameters;
4381 
4382             }
4383 
4384 
4385 
4386             return CloneParameters(cachedParameters);
4387 
4388         }
4389 
4390 
4391 
4392         #endregion 参数集检索结束
4393 
4394     }
4395 
4396 }