if (command == null) throw new ArgumentNullException("command"); if (commandparameters!= null) foreach (SqlParameter p in commandparameters) if (p!= n

Transcription

1 微软 SqlHelper 类中文注释和使用方法整理 : 飞晏博客 ; 网址 : 和微软发布的 SqlHelper.cs 不同, 为了方便我把里面的 SqlHelperParameterCatch.cs 单独 列出来了 此外还有 OledbHelper.cs OdbcHelper.cs 和 XMLHelper.cs 可供使用 SQLHelper.cs 文件源代码和注释 : using System; using System.Collections.Generic; using System.Web; using System.Data; using System.Data.SqlClient; using System.Xml; using System.Collections; using System.Configuration; ///SqlHelper 的摘要说明 public sealed class SqlHelper public SqlHelper() // //TODO: 在此处添加构造函数逻辑 // public static readonly string connectionstring = System.Configuration.ConfigurationManager.ConnectionStrings["testConnectionString"].ConnectionString; #region 私有构造函数和方法 /// 将 SqlParameters 参数数组 ( 参数值 ) 分配给 SqlCommand 命令 /// 这个方法将给任何一个参数分配 DBNull.Value /// 该操作将阻止默认值的使用 ( 大爷的, 没看懂 ) /// <param name="command"> 要分配 SqlParameters 参数的 SqlCommand 命令 </param> /// <param name="commandparameters">sqlparameters 参数数组 </param> private static void AttachParameters(SqlCommand command, SqlParameter[] commandparameters)

2 if (command == null) throw new ArgumentNullException("command"); if (commandparameters!= null) foreach (SqlParameter p in commandparameters) if (p!= null) // Check for derived output value with no value assigned if ((p.direction == ParameterDirection.InputOutput p.direction == ParameterDirection.Input) && (p.value == null)) p.value = DBNull.Value; command.parameters.add(p); /// 将 DataRow 类型的列值分配到 SqlParameter 参数数组 /// <param name="commandparameters"> 要分配的 SqlParameter 参数数组 </param> /// <param name="datarow"> 将要分配给存储过程参数的 DataRow</param> private static void AssignParameterValues(SqlParameter[] commandparameters, DataRow datarow) if ((commandparameters == null) (datarow == null)) // 没有接收到数据就返回 return; int i = 0; // 设置参数值 foreach (SqlParameter commandparameter in commandparameters) // 检查参数名称, 如果不存在, 抛出一个异常 if (commandparameter.parametername == null commandparameter.parametername.length <= 1) throw new Exception( string.format( " 请提供参数 0, 一个有效的名称 1.", i, commandparameter.parametername));

3 // 从 DataRow 的表中获取为参数数组中数组名称的列的索引. // 如果存在和参数名称相同的列, 则将列值赋给当前名称的参数. if (datarow.table.columns.indexof(commandparameter.parametername.substring(1))!= -1) commandparameter.value = datarow[commandparameter.parametername.substring(1)]; i++; /// 将一个对象数组分配给 SqlParameter 参数数组.( 重载方法 ) /// <param name="commandparameters"> 要分配的 SqlParameter 参数数组 </param> /// <param name="parametervalues"> 将要分配给存储过程参数的对象数组 </param> private static void AssignParameterValues(SqlParameter[] commandparameters, object[] parametervalues) if ((commandparameters == null) (parametervalues == null)) return; // 确保对象数组个数与参数个数匹配, 如果不匹配, 抛出一个异常 if (commandparameters.length!= parametervalues.length) throw new ArgumentException(" 参数值个数与参数不匹配."); // 给参数赋值 for (int i = 0, j = commandparameters.length; i < j; i++) if (parametervalues[i] is IDbDataParameter) IDbDataParameter paraminstance = (IDbDataParameter)parameterValues[i]; if (paraminstance.value == null) commandparameters[i].value = DBNull.Value; commandparameters[i].value = paraminstance.value;

4 if (parametervalues[i] == null) commandparameters[i].value = DBNull.Value; commandparameters[i].value = parametervalues[i]; /// 预处理用户提供的命令, 数据库连接 / 事务 / 命令类型 / 参数 /// <param name="command"> 要处理的 SqlCommand</param> /// <param name="connection"> 有效的数据库连接 </param> /// <param name="transaction"> 一个有效的事务或者是 null 值 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本, 其它.)</param> /// <param name="commandtext"> 存储过程名或都 T-SQL 命令文本 </param> /// <param name="commandparameters"> 和命令相关联的 SqlParameter 参数数组, 如果没有参数为 'null'</param> /// <param name="mustcloseconnection"><c>true</c> 如果连接是打开的, 则为 true, 其它情况下为 false.</param> private static void PrepareCommand(SqlCommand command, SqlConnection connection, SqlTransaction transaction, CommandType commandtype, string commandtext, SqlParameter[] commandparameters, out bool mustcloseconnection) if (command == null) throw new ArgumentNullException("command"); if (commandtext == null commandtext.length == 0) throw new ArgumentNullException("commandText"); if (connection.state!= ConnectionState.Open) mustcloseconnection = true; connection.open(); mustcloseconnection = false; command.commandtimeout = 1000 * 60 * 60; // 60 分钟 // 给命令分配一个数据库连接.

5 command.connection = connection; // 设置命令文本 ( 存储过程名或 SQL 语句 ) command.commandtext = commandtext; // 分配事务 if (transaction!= null) if (transaction.connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); command.transaction = transaction; // 设置命令类型. command.commandtype = commandtype; // 分配命令参数 if (commandparameters!= null) AttachParameters(command, commandparameters); return; #endregion 私有构造函数和方法结束 #region ExecuteNonQuery 命令 /// 执行指定连接字符串, 类型的 SqlCommand. /// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders"); /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本, 其它.)</param> /// <param name="commandtext"> 存储过程名称或 SQL 语句 </param> /// <returns> 返回命令影响的行数 </returns> public static int ExecuteNonQuery(string connectionstring, CommandType commandtype, string commandtext) // ExecuteNonQuery #1

6 return ExecuteNonQuery(connectionString, commandtype, commandtext, (SqlParameter[])null); /// 执行指定连接字符串, 类型的 SqlCommand. 如果没有提供参数, 不返回结果 /// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24)); /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本, 其它.)</param> /// <param name="commandtext"> 存储过程名称或 SQL 语句 </param> /// <param name="commandparameters">sqlparameter 参数数组 </param> /// <returns> 返回命令影响的行数 </returns> public static int ExecuteNonQuery(string connectionstring, CommandType commandtype, string commandtext, params SqlParameter[] commandparameters) // ExecuteNonQuery #2 if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); using (SqlConnection connection = new SqlConnection(connectionString)) connection.open(); return ExecuteNonQuery(connection, commandtype, commandtext, commandparameters); /// 执行指定连接字符串的存储过程, 将对象数组的值赋给存储过程参数. /// 此方法需要在参数缓存方法中探索参数并生成参数. /// 这个方法没有提供访问输出参数和返回值. /// int result = ExecuteNonQuery(connString, "PublishOrders", 24, 36); /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="parametervalues"> 分配到存储过程输入参数的对象数组 </param> /// <returns> 返回受影响的行数 </returns> public static int ExecuteNonQuery(string connectionstring, string spname, params object[]

7 parametervalues) // ExecuteNonQuery #3 if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); // 如果存在参数值, 我们要搞清楚他们去哪里 if ((parametervalues!= null) && (parametervalues.length > 0)) // 从探索存储过程参数 ( 加载到缓存 ) 并分配给存储过程参数数组. SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spname); // 给存储过程参数赋值 AssignParameterValues(commandParameters, parametervalues); return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spname, commandparameters); // 没有参数情况下 return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spname); /// 执行指定数据库连接对象的命令. /// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders"); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它.)</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <returns> 返回影响的行数 </returns> public static int ExecuteNonQuery(SqlConnection connection, CommandType commandtype, string commandtext) // ExecuteNonQuery #4 return ExecuteNonQuery(connection, commandtype, commandtext, (SqlParameter[])null);

8 /// 执行指定数据库连接对象的命令 /// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24)); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它.)</param> /// <param name="commandtext">t 存储过程名称或 T-SQL 语句 </param> /// <param name="commandparameters">sqlparamter 参数数组 </param> /// <returns> 返回影响的行数 </returns> public static int ExecuteNonQuery(SqlConnection connection, CommandType commandtype, string commandtext, params SqlParameter[] commandparameters) // ExecuteNonQuery #5 if (connection == null) throw new ArgumentNullException("connection"); SqlCommand cmd = new SqlCommand(); bool mustcloseconnection = false; PrepareCommand(cmd, connection, (SqlTransaction)null, commandtype, commandtext, commandparameters, out mustcloseconnection); int retval = cmd.executenonquery(); cmd.parameters.clear(); if (mustcloseconnection) connection.close(); return retval; /// 执行指定数据库连接对象的命令, 将对象数组的值赋给存储过程参数. /// 此方法不提供访问存储过程输出参数和返回值 /// int result = ExecuteNonQuery(conn, "PublishOrders", 24, 36); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="spname"> 存储过程名 </param> /// <param name="parametervalues"> 分配给存储过程输入参数的对象数组 </param>

9 /// <returns> 返回影响的行数 </returns> public static int ExecuteNonQuery(SqlConnection connection, string spname, params object[] parametervalues) // ExecuteNonQuery #6 if (connection == null) throw new ArgumentNullException("connection"); // 如果有参数值 if ((parametervalues!= null) && (parametervalues.length > 0)) // 从缓存中加载存储过程参数 SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connection, spname); // 给存储过程分配参数值 AssignParameterValues(commandParameters, parametervalues); return ExecuteNonQuery(connection, CommandType.StoredProcedure, spname, commandparameters); return ExecuteNonQuery(connection, CommandType.StoredProcedure, spname); /// 执行带事务的 SqlCommand. /// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders"); /// <param name="transaction"> 一个有效的事物 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它.)</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <returns> 返回影响的行数 </returns> public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandtype, string commandtext) // ExecuteNonQuery #7 return ExecuteNonQuery(transaction, commandtype, commandtext, (SqlParameter[])null);

10 /// 执行带事务的 SqlCommand( 指定参数 ). /// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); /// <param name="transaction"> 一个有效的数据库事物 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它.)</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <param name="commandparameters">sqlparamter 参数数组 </param> /// <returns> 返回影响的行数 </returns> public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandtype, string commandtext, params SqlParameter[] commandparameters) // ExecuteNonQuery #8 if (transaction == null) throw new ArgumentNullException("transaction"); if (transaction!= null && transaction.connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); // 预处理 SqlCommand cmd = new SqlCommand(); bool mustcloseconnection = false; PrepareCommand(cmd, transaction.connection, transaction, commandtype, commandtext, commandparameters, out mustcloseconnection); // 执行 int retval = cmd.executenonquery(); // 清除参数集, 以便再次使用 cmd.parameters.clear(); return retval; /// 执行带事务的 SqlCommand( 指定参数值 ). /// 此方法不提供访问存储过程输出参数和返回值 /// int result = ExecuteNonQuery(conn, trans, "PublishOrders", 24, 36);

11 /// <param name="transaction"> 一个有效的数据库连接对象 </param> /// <param name="spname"> 存储过程名 </param> /// <param name="parametervalues"> 分配给存储过程输入参数的对象数组 </param> /// <returns> 返回受影响的行数 </returns> public static int ExecuteNonQuery(SqlTransaction transaction, string spname, params object[] parametervalues) // ExecuteNonQuery #9 if (transaction == null) throw new ArgumentNullException("transaction"); if (transaction!= null && transaction.connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); // 如果有参数值 if ((parametervalues!= null) && (parametervalues.length > 0)) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spname); // 给存储过程参数赋值 AssignParameterValues(commandParameters, parametervalues); // 调用重载方法 return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spname, commandparameters); // 没有参数值 return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spname); #endregion ExecuteNonQuery 命令 #region ExecuteDataset 方法 /// 执行指定数据库连接字符串的命令, 返回 DataSet.

12 /// DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders"); /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <returns> 返回一个包含结果集的 DataSet</returns> public static DataSet ExecuteDataset(string connectionstring, CommandType commandtype, string commandtext) // ExecuteDataset #1 return ExecuteDataset(connectionString, commandtype, commandtext, (SqlParameter[])null); /// 执行指定数据库连接字符串的命令, 返回 DataSet. /// DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <param name="commandparameters">sqlparamters 参数数组 </param> /// <returns> 返回一个包含结果集的 DataSet</returns> public static DataSet ExecuteDataset(string connectionstring, CommandType commandtype, string commandtext, params SqlParameter[] commandparameters) // ExecuteDataset #2 if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); using (SqlConnection connection = new SqlConnection(connectionString)) connection.open(); return ExecuteDataset(connection, commandtype, commandtext, commandparameters); /// 执行指定数据库连接字符串的命令, 直接提供参数值, 返回 DataSet.

13 /// 此方法不提供访问存储过程输出参数和返回值. /// DataSet ds = ExecuteDataset(connString, "GetOrders", 24, 36); /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="spname"> 存储过程名 </param> /// <param name="parametervalues"> 分配给存储过程输入参数的对象数组 </param> /// <returns> 返回一个包含结果集的 DataSet</returns> public static DataSet ExecuteDataset(string connectionstring, string spname, params object[] parametervalues) // ExecuteDataset #3 if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); if ((parametervalues!= null) && (parametervalues.length > 0)) // 从缓存中检索存储过程参数 SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spname); // 给存储过程参数分配值 AssignParameterValues(commandParameters, parametervalues); return ExecuteDataset(connectionString, CommandType.StoredProcedure, spname, commandparameters); return ExecuteDataset(connectionString, CommandType.StoredProcedure, spname); /// 执行指定数据库连接对象的命令, 返回 DataSet. /// DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders"); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名或 T-SQL 语句 </param>

14 /// <returns> 返回一个包含结果集的 DataSet</returns> public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandtype, string commandtext) // ExecuteDataset #4 return ExecuteDataset(connection, commandtype, commandtext, (SqlParameter[])null); /// 执行指定数据库连接对象的命令, 指定存储过程参数, 返回 DataSet. /// DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名或 T-SQL 语句 </param> /// <param name="commandparameters">sqlparamter 参数数组 </param> /// <returns> 返回一个包含结果集的 DataSet</returns> public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandtype, string commandtext, params SqlParameter[] commandparameters) // ExecuteDataset #5 if (connection == null) throw new ArgumentNullException("connection"); // 预处理 SqlCommand cmd = new SqlCommand(); bool mustcloseconnection = false; PrepareCommand(cmd, connection, (SqlTransaction)null, commandtype, commandtext, commandparameters, out mustcloseconnection); // 创建 SqlDataAdapter 和 DataSet. using (SqlDataAdapter da = new SqlDataAdapter(cmd)) DataSet ds = new DataSet(); // 填充 DataSet. da.fill(ds); cmd.parameters.clear(); if (mustcloseconnection) connection.close(); return ds;

15 /// 执行指定数据库连接对象的命令, 指定参数值, 返回 DataSet. /// 此方法不提供访问存储过程输入参数和返回值. /// 示例.: /// DataSet ds = ExecuteDataset(conn, "GetOrders", 24, 36); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="spname"> 存储过程名 </param> /// <param name="parametervalues"> 分配给存储过程输入参数的对象数组 </param> /// <returns> 返回一个包含结果集的 DataSet</returns> public static DataSet ExecuteDataset(SqlConnection connection, string spname, params object[] parametervalues) // ExecuteDataset #6 if (connection == null) throw new ArgumentNullException("connection"); if ((parametervalues!= null) && (parametervalues.length > 0)) // 比缓存中加载存储过程参数 SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connection, spname); // 给存储过程参数分配值 AssignParameterValues(commandParameters, parametervalues); return ExecuteDataset(connection, CommandType.StoredProcedure, spname, commandparameters); return ExecuteDataset(connection, CommandType.StoredProcedure, spname); /// 执行指定事务的命令, 返回 DataSet. /// DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders"); /// <param name="transaction"> 事务 </param>

16 /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名或 T-SQL 语句 </param> /// <returns> 返回一个包含结果集的 DataSet</returns> public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandtype, string commandtext) // ExecuteDataset #7 return ExecuteDataset(transaction, commandtype, commandtext, (SqlParameter[])null); /// 执行指定事务的命令, 指定参数, 返回 DataSet. /// DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); /// <param name="transaction"> 事务 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名或 T-SQL 语句 </param> /// <param name="commandparameters">sqlparamter 参数数组 </param> /// <returns> 返回一个包含结果集的 DataSet</returns> public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandtype, string commandtext, params SqlParameter[] commandparameters) // ExecuteDataset #8 if (transaction == null) throw new ArgumentNullException("transaction"); if (transaction!= null && transaction.connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); // 预处理 SqlCommand cmd = new SqlCommand(); bool mustcloseconnection = false; PrepareCommand(cmd, transaction.connection, transaction, commandtype, commandtext, commandparameters, out mustcloseconnection); // 创建 DataAdapter & DataSet using (SqlDataAdapter da = new SqlDataAdapter(cmd)) DataSet ds = new DataSet(); da.fill(ds); cmd.parameters.clear(); return ds;

17 /// 执行指定事务的命令, 指定参数值, 返回 DataSet. /// 此方法不提供访问存储过程输入参数和返回值. /// 示例.: /// DataSet ds = ExecuteDataset(trans, "GetOrders", 24, 36); /// <param name="transaction"> 事务 </param> /// <param name="spname"> 存储过程名 </param> /// <param name="parametervalues"> 分配给存储过程输入参数的对象数组 </param> /// <returns> 返回一个包含结果集的 DataSet</returns> public static DataSet ExecuteDataset(SqlTransaction transaction, string spname, params object[] parametervalues) // ExecuteDataset #9 if (transaction == null) throw new ArgumentNullException("transaction"); if (transaction!= null && transaction.connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); if ((parametervalues!= null) && (parametervalues.length > 0)) // 从缓存中加载存储过程参数 SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spname); // 给存储过程参数分配值 AssignParameterValues(commandParameters, parametervalues); return ExecuteDataset(transaction, CommandType.StoredProcedure, spname, commandparameters); return ExecuteDataset(transaction, CommandType.StoredProcedure, spname); #endregion ExecuteDataset 方法 #region ExecuteReader 数据阅读器

18 /// 枚举, 标识数据库连接是由 SqlHelper 提供还是由调用者提供 private enum SqlConnectionOwnership 由 SqlHelper 提供连接 </summary> Internal, 由调用者提供连接 </summary> External /// 执行指定数据库连接对象的数据阅读器. /// 如果是 SqlHelper 打开连接, 当连接关闭 DataReader 也将关闭. /// 如果是调用都打开连接,DataReader 由调用都管理. /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="transaction"> 一个有效的事务, 或者为 'null'</param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名或 T-SQL 语句 </param> /// <param name="commandparameters">sqlparameters 参数数组, 如果没有参数则为 'null'</param> /// <param name="connectionownership"> 标识数据库连接对象是由调用者提供还是由 SqlHelper 提供 </param> /// <returns> 返回包含结果集的 SqlDataReader</returns> private static SqlDataReader ExecuteReader(SqlConnection connection, SqlTransaction transaction, CommandType commandtype, string commandtext, SqlParameter[] commandparameters, SqlConnectionOwnership connectionownership) // ExecuteReader #1 if (connection == null) throw new ArgumentNullException("connection"); bool mustcloseconnection = false; // 创建命令 SqlCommand cmd = new SqlCommand(); try PrepareCommand(cmd, connection, transaction, commandtype, commandtext, commandparameters, out mustcloseconnection); // 创建数据阅读器 SqlDataReader datareader; if (connectionownership == SqlConnectionOwnership.External) datareader = cmd.executereader();

19 datareader = cmd.executereader(commandbehavior.closeconnection); // 清除参数, 以便再次使用.. // HACK: There is a problem here, the output parameter values are fletched // when the reader is closed, so if the parameters are detached from the command // then the SqlReader can 磘 set its values. // When this happen, the parameters can 磘 be used again in other command. bool canclear = true; foreach (SqlParameter commandparameter in cmd.parameters) if (commandparameter.direction!= ParameterDirection.Input) canclear = false; if (canclear) cmd.parameters.clear(); return datareader; catch if (mustcloseconnection) connection.close(); throw; /// 执行指定数据库连接字符串的数据阅读器. /// SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders"); /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名或 T-SQL 语句 </param> /// <returns> 返回包含结果集的 SqlDataReader</returns> public static SqlDataReader ExecuteReader(string connectionstring, CommandType commandtype,

20 string commandtext) // ExecuteReader #2 return ExecuteReader(connectionString, commandtype, commandtext, (SqlParameter[])null); /// 执行指定数据库连接字符串的数据阅读器, 指定参数. /// SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名或 T-SQL 语句 </param> /// <param name="commandparameters">sqlparamter 参数数组 (new SqlParameter("@prodid", 24))</param> /// <returns> 返回包含结果集的 SqlDataReader</returns> public static SqlDataReader ExecuteReader(string connectionstring, CommandType commandtype, string commandtext, params SqlParameter[] commandparameters) // ExecuteReader #3 if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); SqlConnection connection = null; try connection = new SqlConnection(connectionString); connection.open(); return ExecuteReader(connection, null, commandtype, commandtext, commandparameters, SqlConnectionOwnership.Internal); catch if (connection!= null) connection.close(); throw; /// 执行指定数据库连接字符串的数据阅读器, 指定参数值.

21 /// 此方法不提供访问存储过程输出参数和返回值参数. /// SqlDataReader dr = ExecuteReader(connString, "GetOrders", 24, 36); /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="spname"> 存储过程名 </param> /// <param name="parametervalues"> 分配给存储过程输入参数的对象数组 </param> /// <returns> 返回包含结果集的 SqlDataReader</returns> public static SqlDataReader ExecuteReader(string connectionstring, string spname, params object[] parametervalues) // ExecuteReader #4 if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); if ((parametervalues!= null) && (parametervalues.length > 0)) SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spname); AssignParameterValues(commandParameters, parametervalues); return ExecuteReader(connectionString, CommandType.StoredProcedure, spname, commandparameters); return ExecuteReader(connectionString, CommandType.StoredProcedure, spname); /// 执行指定数据库连接对象的数据阅读器. /// SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders"); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名或 T-SQL 语句 </param> /// <returns> 返回包含结果集的 SqlDataReader</returns> public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandtype, string commandtext)

22 // ExecuteReader #5 return ExecuteReader(connection, commandtype, commandtext, (SqlParameter[])null); /// [ 调用者方式 ] 执行指定数据库连接对象的数据阅读器, 指定参数. /// SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名或 T-SQL 语句 </param> /// <param name="commandparameters">sqlparamter 参数数组 </param> /// <returns> 返回包含结果集的 SqlDataReader</returns> public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandtype, string commandtext, params SqlParameter[] commandparameters) // ExecuteReader #6 return ExecuteReader(connection, (SqlTransaction)null, commandtype, commandtext, commandparameters, SqlConnectionOwnership.External); /// [ 调用者方式 ] 执行指定数据库连接对象的数据阅读器, 指定参数值. /// 此方法不提供访问存储过程输出参数和返回值参数. /// SqlDataReader dr = ExecuteReader(conn, "GetOrders", 24, 36); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="spname">t 存储过程名 </param> /// <param name="parametervalues"> 分配给存储过程输入参数的对象数组 </param> /// <returns> 返回包含结果集的 SqlDataReader</returns> public static SqlDataReader ExecuteReader(SqlConnection connection, string spname, params object[] parametervalues) // ExecuteReader #7 if (connection == null) throw new ArgumentNullException("connection"); if ((parametervalues!= null) && (parametervalues.length > 0))

23 SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connection, spname); AssignParameterValues(commandParameters, parametervalues); return ExecuteReader(connection, CommandType.StoredProcedure, spname, commandparameters); return ExecuteReader(connection, CommandType.StoredProcedure, spname); /// [ 调用者方式 ] 执行指定数据库事务的数据阅读器, 指定参数值. /// SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders"); /// <param name="transaction"> 一个有效的连接事务 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <returns> 返回包含结果集的 SqlDataReader</returns> public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandtype, string commandtext) // ExecuteReader #8 return ExecuteReader(transaction, commandtype, commandtext, (SqlParameter[])null); /// [ 调用者方式 ] 执行指定数据库事务的数据阅读器, 指定参数. /// SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); /// <param name="transaction"> 一个有效的连接事务 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <param name="commandparameters"> 分配给命令的 SqlParamter 参数数组 </param> /// <returns> 返回包含结果集的 SqlDataReader</returns>

24 public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandtype, string commandtext, params SqlParameter[] commandparameters) // ExecuteReader #9 if (transaction == null) throw new ArgumentNullException("transaction"); if (transaction!= null && transaction.connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); return ExecuteReader(transaction.Connection, transaction, commandtype, commandtext, commandparameters, SqlConnectionOwnership.External); /// [ 调用者方式 ] 执行指定数据库事务的数据阅读器, 指定参数值. /// 此方法不提供访问存储过程输出参数和返回值参数. /// SqlDataReader dr = ExecuteReader(trans, "GetOrders", 24, 36); /// <param name="transaction"> 一个有效的连接事务 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="parametervalues"> 分配给存储过程输入参数的对象数组 </param> /// <returns> 返回包含结果集的 SqlDataReader</returns> public static SqlDataReader ExecuteReader(SqlTransaction transaction, string spname, params object[] parametervalues) // ExecuteReader #10 if (transaction == null) throw new ArgumentNullException("transaction"); if (transaction!= null && transaction.connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); // 如果有参数值 if ((parametervalues!= null) && (parametervalues.length > 0)) SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spname); AssignParameterValues(commandParameters, parametervalues); return ExecuteReader(transaction, CommandType.StoredProcedure, spname, commandparameters); // 没有参数值 return ExecuteReader(transaction, CommandType.StoredProcedure, spname);

25 #endregion ExecuteReader 数据阅读器 #region ExecuteScalar 返回结果集中的第一行第一列 /// 执行指定数据库连接字符串的命令, 返回结果集中的第一行第一列. /// int ordercount = (int)executescalar(connstring, CommandType.StoredProcedure, "GetOrderCount"); /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <returns> 返回结果集中的第一行第一列 </returns> public static object ExecuteScalar(string connectionstring, CommandType commandtype, string commandtext) // ExecuteScalar #1 // 执行参数为空的方法 return ExecuteScalar(connectionString, commandtype, commandtext, (SqlParameter[])null); /// 执行指定数据库连接字符串的命令, 指定参数, 返回结果集中的第一行第一列. /// int ordercount = (int)executescalar(connstring, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24)); /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <param name="commandparameters"> 分配给命令的 SqlParamter 参数数组 </param> /// <returns> 返回结果集中的第一行第一列 </returns> public static object ExecuteScalar(string connectionstring, CommandType commandtype, string commandtext, params SqlParameter[] commandparameters)

26 // ExecuteScalar #2 if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); // 创建并打开数据库连接对象, 操作完成释放对象. using (SqlConnection connection = new SqlConnection(connectionString)) connection.open(); // 调用指定数据库连接字符串重载方法. return ExecuteScalar(connection, commandtype, commandtext, commandparameters); /// 执行指定数据库连接字符串的命令, 指定参数值, 返回结果集中的第一行第一列. /// 此方法不提供访问存储过程输出参数和返回值参数. /// int ordercount = (int)executescalar(connstring, "GetOrderCount", 24, 36); /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="parametervalues"> 分配给存储过程输入参数的对象数组 </param> /// <returns> 返回结果集中的第一行第一列 </returns> public static object ExecuteScalar(string connectionstring, string spname, params object[] parametervalues) // ExecuteScalar #3 if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); // 如果有参数值 if ((parametervalues!= null) && (parametervalues.length > 0)) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spname); // 给存储过程参数赋值 AssignParameterValues(commandParameters, parametervalues); // 调用重载方法 return ExecuteScalar(connectionString, CommandType.StoredProcedure, spname, commandparameters);

27 // 没有参数值 return ExecuteScalar(connectionString, CommandType.StoredProcedure, spname); /// 执行指定数据库连接对象的命令, 返回结果集中的第一行第一列. /// int ordercount = (int)executescalar(conn, CommandType.StoredProcedure, "GetOrderCount"); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <returns> 返回结果集中的第一行第一列 </returns> public static object ExecuteScalar(SqlConnection connection, CommandType commandtype, string commandtext) // ExecuteScalar #4 // 执行参数为空的方法 return ExecuteScalar(connection, commandtype, commandtext, (SqlParameter[])null); /// 执行指定数据库连接对象的命令, 指定参数, 返回结果集中的第一行第一列. /// int ordercount = (int)executescalar(conn, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24)); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <param name="commandparameters"> 分配给命令的 SqlParamter 参数数组 </param> /// <returns> 返回结果集中的第一行第一列 </returns> public static object ExecuteScalar(SqlConnection connection, CommandType commandtype, string commandtext, params SqlParameter[] commandparameters) // ExecuteScalar #5 if (connection == null) throw new ArgumentNullException("connection");

28 // 创建 SqlCommand 命令, 并进行预处理 SqlCommand cmd = new SqlCommand(); bool mustcloseconnection = false; PrepareCommand(cmd, connection, (SqlTransaction)null, commandtype, commandtext, commandparameters, out mustcloseconnection); // 执行 SqlCommand 命令, 并返回结果. object retval = cmd.executescalar(); // 清除参数, 以便再次使用. cmd.parameters.clear(); if (mustcloseconnection) connection.close(); return retval; /// 执行指定数据库连接对象的命令, 指定参数值, 返回结果集中的第一行第一列. /// 此方法不提供访问存储过程输出参数和返回值参数. /// int ordercount = (int)executescalar(conn, "GetOrderCount", 24, 36); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="parametervalues"> 分配给存储过程输入参数的对象数组 </param> /// <returns> 返回结果集中的第一行第一列 </returns> public static object ExecuteScalar(SqlConnection connection, string spname, params object[] parametervalues) // ExecuteScalar #6 if (connection == null) throw new ArgumentNullException("connection"); // 如果有参数值 if ((parametervalues!= null) && (parametervalues.length > 0)) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connection, spname); // 给存储过程参数赋值 AssignParameterValues(commandParameters, parametervalues); // 调用重载方法 return ExecuteScalar(connection, CommandType.StoredProcedure, spname, commandparameters);

29 // 没有参数值 return ExecuteScalar(connection, CommandType.StoredProcedure, spname); /// 执行指定数据库事务的命令, 返回结果集中的第一行第一列. /// int ordercount = (int)executescalar(trans, CommandType.StoredProcedure, "GetOrderCount"); /// <param name="transaction"> 一个有效的连接事务 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <returns> 返回结果集中的第一行第一列 </returns> public static object ExecuteScalar(SqlTransaction transaction, CommandType commandtype, string commandtext) // ExecuteScalar #7 // 执行参数为空的方法 return ExecuteScalar(transaction, commandtype, commandtext, (SqlParameter[])null); /// 执行指定数据库事务的命令, 指定参数, 返回结果集中的第一行第一列. /// int ordercount = (int)executescalar(trans, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24)); /// <param name="transaction"> 一个有效的连接事务 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <param name="commandparameters"> 分配给命令的 SqlParamter 参数数组 </param> /// <returns> 返回结果集中的第一行第一列 </returns> public static object ExecuteScalar(SqlTransaction transaction, CommandType commandtype, string commandtext, params SqlParameter[] commandparameters) // ExecuteScalar #8

30 if (transaction == null) throw new ArgumentNullException("transaction"); if (transaction!= null && transaction.connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); // 创建 SqlCommand 命令, 并进行预处理 SqlCommand cmd = new SqlCommand(); bool mustcloseconnection = false; PrepareCommand(cmd, transaction.connection, transaction, commandtype, commandtext, commandparameters, out mustcloseconnection); // 执行 SqlCommand 命令, 并返回结果. object retval = cmd.executescalar(); // 清除参数, 以便再次使用. cmd.parameters.clear(); return retval; /// 执行指定数据库事务的命令, 指定参数值, 返回结果集中的第一行第一列. /// 此方法不提供访问存储过程输出参数和返回值参数. /// int ordercount = (int)executescalar(trans, "GetOrderCount", 24, 36); /// <param name="transaction"> 一个有效的连接事务 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="parametervalues"> 分配给存储过程输入参数的对象数组 </param> /// <returns> 返回结果集中的第一行第一列 </returns> public static object ExecuteScalar(SqlTransaction transaction, string spname, params object[] parametervalues) // ExecuteScalar #9 if (transaction == null) throw new ArgumentNullException("transaction"); if (transaction!= null && transaction.connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); // 如果有参数值 if ((parametervalues!= null) && (parametervalues.length > 0)) SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spname);

31 // 给存储过程参数赋值 AssignParameterValues(commandParameters, parametervalues); // 调用重载方法 return ExecuteScalar(transaction, CommandType.StoredProcedure, spname, commandparameters); // 没有参数值 return ExecuteScalar(transaction, CommandType.StoredProcedure, spname); #endregion ExecuteScalar #region ExecuteXmlReader XML 阅读器 /// 执行指定数据库连接对象的 SqlCommand 命令, 并产生一个 XmlReader 对象做为结果集返回. /// XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders"); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 using "FOR XML AUTO"</param> /// <returns> 返回 XmlReader 结果集对象.</returns> public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandtype, string commandtext) // ExecuteXmlReader #1 // 执行参数为空的方法 return ExecuteXmlReader(connection, commandtype, commandtext, (SqlParameter[])null); /// 执行指定数据库连接对象的 SqlCommand 命令, 并产生一个 XmlReader 对象做为结果集返回, 指定参数.

32 /// XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 using "FOR XML AUTO"</param> /// <param name="commandparameters"> 分配给命令的 SqlParamter 参数数组 </param> /// <returns> 返回 XmlReader 结果集对象.</returns> public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandtype, string commandtext, params SqlParameter[] commandparameters) // ExecuteXmlReader #2 if (connection == null) throw new ArgumentNullException("connection"); bool mustcloseconnection = false; // 创建 SqlCommand 命令, 并进行预处理 SqlCommand cmd = new SqlCommand(); try PrepareCommand(cmd, connection, (SqlTransaction)null, commandtype, commandtext, commandparameters, out mustcloseconnection); // 执行命令 XmlReader retval = cmd.executexmlreader(); // 清除参数, 以便再次使用. cmd.parameters.clear(); return retval; catch if (mustcloseconnection) connection.close(); throw; /// 执行指定数据库连接对象的 SqlCommand 命令, 并产生一个 XmlReader 对象做为结果集返回, 指定参数值. /// 此方法不提供访问存储过程输出参数和返回值参数.

33 /// XmlReader r = ExecuteXmlReader(conn, "GetOrders", 24, 36); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="spname"> 存储过程名称 using "FOR XML AUTO"</param> /// <param name="parametervalues"> 分配给存储过程输入参数的对象数组 </param> /// <returns> 返回 XmlReader 结果集对象.</returns> public static XmlReader ExecuteXmlReader(SqlConnection connection, string spname, params object[] parametervalues) // ExecuteXmlReader #3 if (connection == null) throw new ArgumentNullException("connection"); // 如果有参数值 if ((parametervalues!= null) && (parametervalues.length > 0)) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connection, spname); // 给存储过程参数赋值 AssignParameterValues(commandParameters, parametervalues); // 调用重载方法 return ExecuteXmlReader(connection, CommandType.StoredProcedure, spname, commandparameters); // 没有参数值 return ExecuteXmlReader(connection, CommandType.StoredProcedure, spname); /// 执行指定数据库事务的 SqlCommand 命令, 并产生一个 XmlReader 对象做为结果集返回. /// XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders"); /// <param name="transaction"> 一个有效的连接事务 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param>

34 /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 using "FOR XML AUTO"</param> /// <returns> 返回 XmlReader 结果集对象.</returns> public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandtype, string commandtext) // ExecuteXmlReader #4 // 执行参数为空的方法 return ExecuteXmlReader(transaction, commandtype, commandtext, (SqlParameter[])null); /// 执行指定数据库事务的 SqlCommand 命令, 并产生一个 XmlReader 对象做为结果集返回, 指定参数. /// XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24)); /// <param name="transaction"> 一个有效的连接事务 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 using "FOR XML AUTO"</param> /// <param name="commandparameters"> 分配给命令的 SqlParamter 参数数组 </param> /// <returns> 返回 XmlReader 结果集对象.</returns> public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandtype, string commandtext, params SqlParameter[] commandparameters) // ExecuteXmlReader #5 if (transaction == null) throw new ArgumentNullException("transaction"); if (transaction!= null && transaction.connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); // 创建 SqlCommand 命令, 并进行预处理 SqlCommand cmd = new SqlCommand(); bool mustcloseconnection = false; PrepareCommand(cmd, transaction.connection, transaction, commandtype, commandtext, commandparameters, out mustcloseconnection); // 执行命令 XmlReader retval = cmd.executexmlreader(); // 清除参数, 以便再次使用. cmd.parameters.clear(); return retval;

35 /// 执行指定数据库事务的 SqlCommand 命令, 并产生一个 XmlReader 对象做为结果集返回, 指定参数值. /// 此方法不提供访问存储过程输出参数和返回值参数. /// XmlReader r = ExecuteXmlReader(trans, "GetOrders", 24, 36); /// <param name="transaction"> 一个有效的连接事务 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="parametervalues"> 分配给存储过程输入参数的对象数组 </param> /// <returns> 返回一个包含结果集的 DataSet.</returns> public static XmlReader ExecuteXmlReader(SqlTransaction transaction, string spname, params object[] parametervalues) // ExecuteXmlReader #6 if (transaction == null) throw new ArgumentNullException("transaction"); if (transaction!= null && transaction.connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); // 如果有参数值 if ((parametervalues!= null) && (parametervalues.length > 0)) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spname); // 给存储过程参数赋值 AssignParameterValues(commandParameters, parametervalues); // 调用重载方法 return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spname, commandparameters); // 没有参数值 return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spname);

36 #endregion ExecuteXmlReader 阅读器结束 #region FillDataset 填充数据集 /// 执行指定数据库连接字符串的命令, 映射数据表并填充数据集. /// FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] "orders"); /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <param name="dataset"> 要填充结果集的 DataSet 实例 </param> /// <param name="tablenames"> 表映射的数据表数组 /// 用户定义的表名 ( 可有是实际的表名.)</param> public static void FillDataset(string connectionstring, CommandType commandtype, string commandtext, DataSet dataset, string[] tablenames) // FillDataset #1 if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); if (dataset == null) throw new ArgumentNullException("dataSet"); // 创建并打开数据库连接对象, 操作完成释放对象. using (SqlConnection connection = new SqlConnection(connectionString)) connection.open(); // 调用指定数据库连接字符串重载方法. FillDataset(connection, commandtype, commandtext, dataset, tablenames); /// 执行指定数据库连接字符串的命令, 映射数据表并填充数据集. 指定命令参数. /// FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] "orders",

37 new 24)); /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <param name="dataset"> 分配给命令的 SqlParamter 参数数组 </param> /// <param name="tablenames"> 要填充结果集的 DataSet 实例 </param> /// <param name="commandparameters"> 表映射的数据表数组 /// 用户定义的表名 ( 可有是实际的表名.) /// </param> public static void FillDataset(string connectionstring, CommandType commandtype, string commandtext, DataSet dataset, string[] tablenames, params SqlParameter[] commandparameters) // FillDataset #2 if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); if (dataset == null) throw new ArgumentNullException("dataSet"); // 创建并打开数据库连接对象, 操作完成释放对象. using (SqlConnection connection = new SqlConnection(connectionString)) connection.open(); // 调用指定数据库连接字符串重载方法. FillDataset(connection, commandtype, commandtext, dataset, tablenames, commandparameters); /// 执行指定数据库连接字符串的命令, 映射数据表并填充数据集, 指定存储过程参数值. /// 此方法不提供访问存储过程输出参数和返回值参数. /// FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] "orders", 24); /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="dataset"> 要填充结果集的 DataSet 实例 </param> /// <param name="tablenames"> 表映射的数据表数组 /// 用户定义的表名 ( 可有是实际的表名.) /// </param>

38 /// <param name="parametervalues"> 分配给存储过程输入参数的对象数组 </param> public static void FillDataset(string connectionstring, string spname, DataSet dataset, string[] tablenames, params object[] parametervalues) // FillDataset #3 if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); if (dataset == null) throw new ArgumentNullException("dataSet"); // 创建并打开数据库连接对象, 操作完成释放对象. using (SqlConnection connection = new SqlConnection(connectionString)) connection.open(); // 调用指定数据库连接字符串重载方法. FillDataset(connection, spname, dataset, tablenames, parametervalues); /// 执行指定数据库连接对象的命令, 映射数据表并填充数据集. /// FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] "orders"); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <param name="dataset"> 要填充结果集的 DataSet 实例 </param> /// <param name="tablenames"> 表映射的数据表数组 /// 用户定义的表名 ( 可有是实际的表名.) /// </param> public static void FillDataset(SqlConnection connection, CommandType commandtype, string commandtext, DataSet dataset, string[] tablenames) // FillDataset #4 FillDataset(connection, commandtype, commandtext, dataset, tablenames, null); /// 执行指定数据库连接对象的命令, 映射数据表并填充数据集, 指定参数. /// FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] "orders", new

39 24)); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <param name="dataset"> 要填充结果集的 DataSet 实例 </param> /// <param name="tablenames"> 表映射的数据表数组 /// 用户定义的表名 ( 可有是实际的表名.) /// </param> /// <param name="commandparameters"> 分配给命令的 SqlParamter 参数数组 </param> public static void FillDataset(SqlConnection connection, CommandType commandtype, string commandtext, DataSet dataset, string[] tablenames, params SqlParameter[] commandparameters) // FillDataset #5 FillDataset(connection, null, commandtype, commandtext, dataset, tablenames, commandparameters); /// 执行指定数据库连接对象的命令, 映射数据表并填充数据集, 指定存储过程参数值. /// 此方法不提供访问存储过程输出参数和返回值参数. /// FillDataset(conn, "GetOrders", ds, new string[] "orders", 24, 36); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="dataset"> 要填充结果集的 DataSet 实例 </param> /// <param name="tablenames"> 表映射的数据表数组 /// 用户定义的表名 ( 可有是实际的表名.) /// </param> /// <param name="parametervalues"> 分配给存储过程输入参数的对象数组 </param> public static void FillDataset(SqlConnection connection, string spname, DataSet dataset, string[] tablenames, params object[] parametervalues) // FillDataset #6 if (connection == null) throw new ArgumentNullException("connection"); if (dataset == null) throw new ArgumentNullException("dataSet"); // 如果有参数值 if ((parametervalues!= null) && (parametervalues.length > 0))

40 // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connection, spname); // 给存储过程参数赋值 AssignParameterValues(commandParameters, parametervalues); // 调用重载方法 FillDataset(connection, CommandType.StoredProcedure, spname, dataset, tablenames, commandparameters); // 没有参数值 FillDataset(connection, CommandType.StoredProcedure, spname, dataset, tablenames); /// 执行指定数据库事务的命令, 映射数据表并填充数据集. /// FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] "orders"); /// <param name="transaction"> 一个有效的连接事务 </param> /// <param name="commandtype"> 命令类型 ( 存储过程, 命令文本或其它 )</param> /// <param name="commandtext"> 存储过程名称或 T-SQL 语句 </param> /// <param name="dataset"> 要填充结果集的 DataSet 实例 </param> /// <param name="tablenames"> 表映射的数据表数组 /// 用户定义的表名 ( 可有是实际的表名.) /// </param> public static void FillDataset(SqlTransaction transaction, CommandType commandtype, string commandtext, DataSet dataset, string[] tablenames) // FillDataset #7 FillDataset(transaction, commandtype, commandtext, dataset, tablenames, null); /// 执行指定数据库事务的命令, 映射数据表并填充数据集, 指定参数.