微软 SqlHelper 类中文注释和使用方法整理 : 飞晏博客 ; 网址 :http://www.feiyan.info/416.html 和微软发布的 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)
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));
// 从 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;
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 分钟 // 给命令分配一个数据库连接.
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
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[]
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);
/// 执行指定数据库连接对象的命令 /// 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>
/// <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);
/// 执行带事务的 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);
/// <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.
/// 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.
/// 此方法不提供访问存储过程输出参数和返回值. /// 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>
/// <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;
/// 执行指定数据库连接对象的命令, 指定参数值, 返回 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>
/// <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;
/// 执行指定事务的命令, 指定参数值, 返回 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 数据阅读器
/// 枚举, 标识数据库连接是由 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();
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,
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; /// 执行指定数据库连接字符串的数据阅读器, 指定参数值.
/// 此方法不提供访问存储过程输出参数和返回值参数. /// 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)
// 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))
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>
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);
#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)
// 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);
// 没有参数值 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");
// 创建 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);
// 没有参数值 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
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);
// 给存储过程参数赋值 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 对象做为结果集返回, 指定参数.
/// 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 对象做为结果集返回, 指定参数值. /// 此方法不提供访问存储过程输出参数和返回值参数.
/// 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>
/// <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;
/// 执行指定数据库事务的 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);
#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",
new SqlParameter("@prodid", 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>
/// <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
SqlParameter("@prodid", 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))
// 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () 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); /// 执行指定数据库事务的命令, 映射数据表并填充数据集, 指定参数.
/// FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] "orders", new SqlParameter("@prodid", 24)); /// <param name="transaction"> 一个有效的连接事务 </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(SqlTransaction transaction, CommandType commandtype, string commandtext, DataSet dataset, string[] tablenames, params SqlParameter[] commandparameters) // FillDataset #8 FillDataset(transaction.Connection, transaction, commandtype, commandtext, dataset, tablenames, commandparameters); /// 执行指定数据库事务的命令, 映射数据表并填充数据集, 指定存储过程参数值. /// 此方法不提供访问存储过程输出参数和返回值参数. /// FillDataset(trans, "GetOrders", ds, new string[]"orders", 24, 36); /// <param name="transaction"> 一个有效的连接事务 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="dataset"> 要填充结果集的 DataSet 实例 </param> /// <param name="tablenames"> 表映射的数据表数组 /// 用户定义的表名 ( 可有是实际的表名.) /// </param> /// <param name="parametervalues"> 分配给存储过程输入参数的对象数组 </param> public static void FillDataset(SqlTransaction transaction, string spname, DataSet dataset, string[] tablenames, params object[] parametervalues) // FillDataset #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 (dataset == null) throw new ArgumentNullException("dataSet");
// 如果有参数值 if ((parametervalues!= null) && (parametervalues.length > 0)) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spname); // 给存储过程参数赋值 AssignParameterValues(commandParameters, parametervalues); // 调用重载方法 FillDataset(transaction, CommandType.StoredProcedure, spname, dataset, tablenames, commandparameters); // 没有参数值 FillDataset(transaction, CommandType.StoredProcedure, spname, dataset, tablenames); /// [ 私有方法 ][ 内部调用 ] 执行指定数据库连接对象 / 事务的命令, 映射数据表并填充数据集,DataSet/TableNames/SqlParameters. /// FillDataset(conn, trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] "orders", new SqlParameter("@prodid", 24)); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="transaction"> 一个有效的连接事务 </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> private static void FillDataset(SqlConnection connection, SqlTransaction transaction, CommandType commandtype, string commandtext, DataSet dataset, string[] tablenames, params SqlParameter[]
commandparameters) // FillDataset #10 if (connection == null) throw new ArgumentNullException("connection"); if (dataset == null) throw new ArgumentNullException("dataSet"); // 创建 SqlCommand 命令, 并进行预处理 SqlCommand command = new SqlCommand(); bool mustcloseconnection = false; PrepareCommand(command, connection, transaction, commandtype, commandtext, commandparameters, out mustcloseconnection); // 执行命令 using (SqlDataAdapter dataadapter = new SqlDataAdapter(command)) // 追加表映射 if (tablenames!= null && tablenames.length > 0) string tablename = "Table"; for (int index = 0; index < tablenames.length; index++) 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"); dataadapter.tablemappings.add(tablename, tablenames[index]); tablename += (index + 1).ToString(); // 填充数据集使用默认表名称 dataadapter.fill(dataset); // 清除参数, 以便再次使用. command.parameters.clear(); if (mustcloseconnection) connection.close(); #endregion FillDataset 填充数据集 #region UpdateDataset 更新数据集
/// 执行数据集更新到数据库, 指定 inserted, updated, or deleted 命令. /// UpdateDataset(conn, insertcommand, deletecommand, updatecommand, dataset, "Order"); /// <param name="insertcommand">[ 追加记录 ] 一个有效的 T-SQL 语句或存储过程 </param> /// <param name="deletecommand">[ 删除记录 ] 一个有效的 T-SQL 语句或存储过程 </param> /// <param name="updatecommand">[ 更新记录 ] 一个有效的 T-SQL 语句或存储过程 </param> /// <param name="dataset"> 要更新到数据库的 DataSet</param> /// <param name="tablename"> 要更新到数据库的 DataTable</param> public static void UpdateDataset(SqlCommand insertcommand, SqlCommand deletecommand, SqlCommand updatecommand, DataSet dataset, string tablename) if (insertcommand == null) throw new ArgumentNullException("insertCommand"); if (deletecommand == null) throw new ArgumentNullException("deleteCommand"); if (updatecommand == null) throw new ArgumentNullException("updateCommand"); if (tablename == null tablename.length == 0) throw new ArgumentNullException("tableName"); // 创建 SqlDataAdapter, 当操作完成后释放. using (SqlDataAdapter dataadapter = new SqlDataAdapter()) // 设置数据适配器命令 dataadapter.updatecommand = updatecommand; dataadapter.insertcommand = insertcommand; dataadapter.deletecommand = deletecommand; // 更新数据集改变到数据库 dataadapter.update(dataset, tablename); // 提交所有改变到数据集. dataset.acceptchanges(); #endregion UpdateDataset 更新数据集 #region CreateCommand 创建一条 SqlCommand 命令 /// 创建 SqlCommand 命令, 指定数据库连接对象, 存储过程名和参数.
/// SqlCommand command = CreateCommand(conn, "AddCustomer", "CustomerID", "CustomerName"); /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="sourcecolumns"> 源表的列名称数组 </param> /// <returns> 返回 SqlCommand 命令 </returns> public static SqlCommand CreateCommand(SqlConnection connection, string spname, params string[] sourcecolumns) // CreateCommand #1 if (connection == null) throw new ArgumentNullException("connection"); // 创建命令 SqlCommand cmd = new SqlCommand(spName, connection); cmd.commandtype = CommandType.StoredProcedure; // 如果有参数值 if ((sourcecolumns!= null) && (sourcecolumns.length > 0)) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connection, spname); // 将源表的列到映射到 DataSet 命令中. for (int index = 0; index < sourcecolumns.length; index++) commandparameters[index].sourcecolumn = sourcecolumns[index]; // Attach the discovered parameters to the SqlCommand object AttachParameters(cmd, commandparameters); return cmd; #endregion CreateCommand 创建一条 SqlCommand 命令 #region ExecuteNonQueryTypedParams 类型化参数 (DataRow)
/// 执行指定连接数据库连接字符串的存储过程, 使用 DataRow 做为参数值, 返回受影响的行数. /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="datarow"> 使用 DataRow 作为参数值 </param> /// <returns> 返回影响的行数 </returns> public static int ExecuteNonQueryTypedParams(String connectionstring, String spname, DataRow datarow) // ExecuteNonQueryTypedParams #1 if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); // 如果 row 有值, 存储过程必须初始化. if (datarow!= null && datarow.itemarray.length > 0) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spname); // 分配参数值 AssignParameterValues(commandParameters, datarow); return SqlHelper.ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spname, commandparameters); return SqlHelper.ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spname); /// 执行指定连接数据库连接对象的存储过程, 使用 DataRow 做为参数值, 返回受影响的行数. /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="datarow"> 使用 DataRow 作为参数值 </param> /// <returns> 返回影响的行数 </returns> public static int ExecuteNonQueryTypedParams(SqlConnection connection, String spname, DataRow datarow)
// ExecuteNonQueryTypedParams #2 if (connection == null) throw new ArgumentNullException("connection"); // 如果 row 有值, 存储过程必须初始化. if (datarow!= null && datarow.itemarray.length > 0) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connection, spname); // 分配参数值 AssignParameterValues(commandParameters, datarow); return SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, spname, commandparameters); return SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, spname); /// 执行指定连接数据库事物的存储过程, 使用 DataRow 做为参数值, 返回受影响的行数. /// <param name="transaction"> 一个有效的连接事务 object</param> /// <param name="spname"> 存储过程名称 </param> /// <param name="datarow"> 使用 DataRow 作为参数值 </param> /// <returns> 返回影响的行数 </returns> public static int ExecuteNonQueryTypedParams(SqlTransaction transaction, String spname, DataRow datarow) // ExecuteNonQueryTypedParams #3 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"); // Sf the row has values, the store procedure parameters must be initialized if (datarow!= null && datarow.itemarray.length > 0)
// 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spname); // 分配参数值 AssignParameterValues(commandParameters, datarow); return SqlHelper.ExecuteNonQuery(transaction, CommandType.StoredProcedure, spname, commandparameters); return SqlHelper.ExecuteNonQuery(transaction, CommandType.StoredProcedure, spname); #endregion ExecuteNonQueryTypedParams 类型化参数 (DataRow) #region ExecuteDatasetTypedParams 类型化参数 (DataRow) /// 执行指定连接数据库连接字符串的存储过程, 使用 DataRow 做为参数值, 返回 DataSet. /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="datarow"> 使用 DataRow 作为参数值 </param> /// <returns> 返回一个包含结果集的 DataSet.</returns> public static DataSet ExecuteDatasetTypedParams(string connectionstring, String spname, DataRow datarow) // ExecuteDatasetTypedParams #1 if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); // 如果 row 有值, 存储过程必须初始化. if (datarow!= null && datarow.itemarray.length > 0) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spname); // 分配参数值
AssignParameterValues(commandParameters, datarow); return SqlHelper.ExecuteDataset(connectionString, CommandType.StoredProcedure, spname, commandparameters); return SqlHelper.ExecuteDataset(connectionString, CommandType.StoredProcedure, spname); /// 执行指定连接数据库连接对象的存储过程, 使用 DataRow 做为参数值, 返回 DataSet. /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="datarow"> 使用 DataRow 作为参数值 </param> /// <returns> 返回一个包含结果集的 DataSet.</returns> public static DataSet ExecuteDatasetTypedParams(SqlConnection connection, String spname, DataRow datarow) // ExecuteDatasetTypedParams #2 if (connection == null) throw new ArgumentNullException("connection"); // 如果 row 有值, 存储过程必须初始化. if (datarow!= null && datarow.itemarray.length > 0) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connection, spname); // 分配参数值 AssignParameterValues(commandParameters, datarow); return SqlHelper.ExecuteDataset(connection, CommandType.StoredProcedure, spname, commandparameters); return SqlHelper.ExecuteDataset(connection, CommandType.StoredProcedure, spname);
/// 执行指定连接数据库事务的存储过程, 使用 DataRow 做为参数值, 返回 DataSet. /// <param name="transaction"> 一个有效的连接事务 object</param> /// <param name="spname"> 存储过程名称 </param> /// <param name="datarow"> 使用 DataRow 作为参数值 </param> /// <returns> 返回一个包含结果集的 DataSet.</returns> public static DataSet ExecuteDatasetTypedParams(SqlTransaction transaction, String spname, DataRow datarow) // ExecuteDatasetTypedParams #3 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"); // 如果 row 有值, 存储过程必须初始化. if (datarow!= null && datarow.itemarray.length > 0) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spname); // 分配参数值 AssignParameterValues(commandParameters, datarow); return SqlHelper.ExecuteDataset(transaction, CommandType.StoredProcedure, spname, commandparameters); return SqlHelper.ExecuteDataset(transaction, CommandType.StoredProcedure, spname); #endregion ExecuteDatasetTypedParams 类型化参数 (DataRow) #region ExecuteReaderTypedParams 类型化参数 (DataRow)
/// 执行指定连接数据库连接字符串的存储过程, 使用 DataRow 做为参数值, 返回 DataReader. /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="datarow"> 使用 DataRow 作为参数值 </param> /// <returns> 返回包含结果集的 SqlDataReader</returns> public static SqlDataReader ExecuteReaderTypedParams(String connectionstring, String spname, DataRow datarow) // ExecuteReaderTypedParams #1 if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); // 如果 row 有值, 存储过程必须初始化. if (datarow!= null && datarow.itemarray.length > 0) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spname); // 分配参数值 AssignParameterValues(commandParameters, datarow); return SqlHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, spname, commandparameters); return SqlHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, spname); /// 执行指定连接数据库连接对象的存储过程, 使用 DataRow 做为参数值, 返回 DataReader. /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="datarow"> 使用 DataRow 作为参数值 </param> /// <returns> 返回包含结果集的 SqlDataReader</returns> public static SqlDataReader ExecuteReaderTypedParams(SqlConnection connection, String spname, DataRow datarow)
// ExecuteReaderTypedParams #2 if (connection == null) throw new ArgumentNullException("connection"); // 如果 row 有值, 存储过程必须初始化. if (datarow!= null && datarow.itemarray.length > 0) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connection, spname); // 分配参数值 AssignParameterValues(commandParameters, datarow); return SqlHelper.ExecuteReader(connection, CommandType.StoredProcedure, spname, commandparameters); return SqlHelper.ExecuteReader(connection, CommandType.StoredProcedure, spname); /// 执行指定连接数据库事物的存储过程, 使用 DataRow 做为参数值, 返回 DataReader. /// <param name="transaction"> 一个有效的连接事务 object</param> /// <param name="spname"> 存储过程名称 </param> /// <param name="datarow"> 使用 DataRow 作为参数值 </param> /// <returns> 返回包含结果集的 SqlDataReader</returns> public static SqlDataReader ExecuteReaderTypedParams(SqlTransaction transaction, String spname, DataRow datarow) // ExecuteReaderTypedParams #3 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"); // 如果 row 有值, 存储过程必须初始化. if (datarow!= null && datarow.itemarray.length > 0)
// 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spname); // 分配参数值 AssignParameterValues(commandParameters, datarow); return SqlHelper.ExecuteReader(transaction, CommandType.StoredProcedure, spname, commandparameters); return SqlHelper.ExecuteReader(transaction, CommandType.StoredProcedure, spname); #endregion ExecuteReaderTypedParams 类型化参数 (DataRow) #region ExecuteScalarTypedParams 类型化参数 (DataRow) /// 执行指定连接数据库连接字符串的存储过程, 使用 DataRow 做为参数值, 返回结果集中的第一行第一列. /// <param name="connectionstring"> 一个有效的数据库连接字符串 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="datarow"> 使用 DataRow 作为参数值 </param> /// <returns> 返回结果集中的第一行第一列 </returns> public static object ExecuteScalarTypedParams(String connectionstring, String spname, DataRow datarow) // ExecuteScalarTypedParams #1 if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); // 如果 row 有值, 存储过程必须初始化. if (datarow!= null && datarow.itemarray.length > 0) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters =
SqlHelperParameterCache.GetSpParameterSet(connectionString, spname); // 分配参数值 AssignParameterValues(commandParameters, datarow); return SqlHelper.ExecuteScalar(connectionString, CommandType.StoredProcedure, spname, commandparameters); return SqlHelper.ExecuteScalar(connectionString, CommandType.StoredProcedure, spname); /// 执行指定连接数据库连接对象的存储过程, 使用 DataRow 做为参数值, 返回结果集中的第一行第一列. /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="datarow"> 使用 DataRow 作为参数值 </param> /// <returns> 返回结果集中的第一行第一列 </returns> public static object ExecuteScalarTypedParams(SqlConnection connection, String spname, DataRow datarow) // ExecuteScalarTypedParams #2 if (connection == null) throw new ArgumentNullException("connection"); // 如果 row 有值, 存储过程必须初始化. if (datarow!= null && datarow.itemarray.length > 0) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connection, spname); // 分配参数值 AssignParameterValues(commandParameters, datarow); commandparameters); return SqlHelper.ExecuteScalar(connection, CommandType.StoredProcedure, spname,
return SqlHelper.ExecuteScalar(connection, CommandType.StoredProcedure, spname); /// 执行指定连接数据库事务的存储过程, 使用 DataRow 做为参数值, 返回结果集中的第一行第一列. /// <param name="transaction"> 一个有效的连接事务 object</param> /// <param name="spname"> 存储过程名称 </param> /// <param name="datarow"> 使用 DataRow 作为参数值 </param> /// <returns> 返回结果集中的第一行第一列 </returns> public static object ExecuteScalarTypedParams(SqlTransaction transaction, String spname, DataRow datarow) // ExecuteScalarTypedParams #3 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"); // 如果 row 有值, 存储过程必须初始化. if (datarow!= null && datarow.itemarray.length > 0) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spname); // 分配参数值 AssignParameterValues(commandParameters, datarow); return SqlHelper.ExecuteScalar(transaction, CommandType.StoredProcedure, spname, commandparameters); return SqlHelper.ExecuteScalar(transaction, CommandType.StoredProcedure, spname); #endregion ExecuteScalarTypedParams 类型化参数 (DataRow)
#region ExecuteXmlReaderTypedParams 类型化参数 (DataRow) /// 执行指定连接数据库连接对象的存储过程, 使用 DataRow 做为参数值, 返回 XmlReader 类型的结果集. /// <param name="connection"> 一个有效的数据库连接对象 </param> /// <param name="spname"> 存储过程名称 </param> /// <param name="datarow"> 使用 DataRow 作为参数值 </param> /// <returns> 返回 XmlReader 结果集对象.</returns> public static XmlReader ExecuteXmlReaderTypedParams(SqlConnection connection, String spname, DataRow datarow) // ExecuteXmlReaderTypedParams #1 if (connection == null) throw new ArgumentNullException("connection"); // 如果 row 有值, 存储过程必须初始化. if (datarow!= null && datarow.itemarray.length > 0) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(connection, spname); // 分配参数值 AssignParameterValues(commandParameters, datarow); return SqlHelper.ExecuteXmlReader(connection, CommandType.StoredProcedure, spname, commandparameters); return SqlHelper.ExecuteXmlReader(connection, CommandType.StoredProcedure, spname); /// 执行指定连接数据库事务的存储过程, 使用 DataRow 做为参数值, 返回 XmlReader 类型的结果集. /// <param name="transaction"> 一个有效的连接事务 object</param> /// <param name="spname"> 存储过程名称 </param>
/// <param name="datarow"> 使用 DataRow 作为参数值 </param> /// <returns> 返回 XmlReader 结果集对象.</returns> public static XmlReader ExecuteXmlReaderTypedParams(SqlTransaction transaction, String spname, DataRow datarow) // ExecuteXmlReaderTypedParams #2 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"); // 如果 row 有值, 存储过程必须初始化. if (datarow!= null && datarow.itemarray.length > 0) // 从缓存中加载存储过程参数, 如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. () SqlParameter[] commandparameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spname); // 分配参数值 AssignParameterValues(commandParameters, datarow); return SqlHelper.ExecuteXmlReader(transaction, CommandType.StoredProcedure, spname, commandparameters); return SqlHelper.ExecuteXmlReader(transaction, CommandType.StoredProcedure, spname); #endregion ExecuteXmlReaderTypedParams 类型化参数 (DataRow) SqlHelperParameterCatch.cs 文件源代码和注释 : using System; using System.Collections.Generic; using System.Web; using System.Data.SqlClient; using System.Collections; using System.Data;
///SqlHelperParameterCache 的摘要说明 public sealed class SqlHelperParameterCache #region private methods, variables, and constructors //Since this class provides only static methods, make the default constructor private to prevent //instances from being created with "new SqlHelperParameterCache()" private SqlHelperParameterCache() private static Hashtable paramcache = Hashtable.Synchronized(new Hashtable()); /// Resolve at run time the appropriate set of SqlParameters for a stored procedure /// <param name="connection">a valid SqlConnection object</param> /// <param name="spname">the name of the stored procedure</param> /// <param name="includereturnvalueparameter">whether or not to include their return value parameter</param> /// <returns>the parameter array discovered.</returns> private static SqlParameter[] DiscoverSpParameterSet(SqlConnection connection, string spname, bool includereturnvalueparameter) if (connection == null) throw new ArgumentNullException("connection"); SqlCommand cmd = new SqlCommand(spName, connection); cmd.commandtype = CommandType.StoredProcedure; connection.open(); SqlCommandBuilder.DeriveParameters(cmd); connection.close(); if (!includereturnvalueparameter) cmd.parameters.removeat(0); SqlParameter[] discoveredparameters = new SqlParameter[cmd.Parameters.Count]; cmd.parameters.copyto(discoveredparameters, 0); // Init the parameters with a DBNull value
foreach (SqlParameter discoveredparameter in discoveredparameters) discoveredparameter.value = DBNull.Value; return discoveredparameters; /// Deep copy of cached SqlParameter array /// <param name="originalparameters"></param> /// <returns></returns> private static SqlParameter[] CloneParameters(SqlParameter[] originalparameters) SqlParameter[] clonedparameters = new SqlParameter[originalParameters.Length]; for (int i = 0, j = originalparameters.length; i < j; i++) clonedparameters[i] = (SqlParameter)((ICloneable)originalParameters[i]).Clone(); return clonedparameters; #endregion private methods, variables, and constructors #region caching functions /// Add parameter array to the cache /// <param name="connectionstring">a valid connection string for a SqlConnection</param> /// <param name="commandtext">the stored procedure name or T-SQL command</param> /// <param name="commandparameters">an array of SqlParamters to be cached</param> public static void CacheParameterSet(string connectionstring, string commandtext, params SqlParameter[] commandparameters) if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); if (commandtext == null commandtext.length == 0) throw new ArgumentNullException("commandText"); string hashkey = connectionstring + ":" + commandtext;
paramcache[hashkey] = commandparameters; /// Retrieve a parameter array from the cache /// <param name="connectionstring">a valid connection string for a SqlConnection</param> /// <param name="commandtext">the stored procedure name or T-SQL command</param> /// <returns>an array of SqlParamters</returns> public static SqlParameter[] GetCachedParameterSet(string connectionstring, string commandtext) if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); if (commandtext == null commandtext.length == 0) throw new ArgumentNullException("commandText"); string hashkey = connectionstring + ":" + commandtext; SqlParameter[] cachedparameters = paramcache[hashkey] as SqlParameter[]; if (cachedparameters == null) return null; return CloneParameters(cachedParameters); #endregion caching functions #region Parameter Discovery Functions /// Retrieves the set of SqlParameters appropriate for the stored procedure /// This method will query the database for this information, and then store it in a cache for future requests. /// <param name="connectionstring">a valid connection string for a SqlConnection</param> /// <param name="spname">the name of the stored procedure</param> /// <returns>an array of SqlParameters</returns> public static SqlParameter[] GetSpParameterSet(string connectionstring, string spname)
return GetSpParameterSet(connectionString, spname, false); /// Retrieves the set of SqlParameters appropriate for the stored procedure /// This method will query the database for this information, and then store it in a cache for future requests. /// <param name="connectionstring">a valid connection string for a SqlConnection</param> /// <param name="spname">the name of the stored procedure</param> /// <param name="includereturnvalueparameter">a bool value indicating whether the return value parameter should be included in the results</param> /// <returns>an array of SqlParameters</returns> public static SqlParameter[] GetSpParameterSet(string connectionstring, string spname, bool includereturnvalueparameter) if (connectionstring == null connectionstring.length == 0) throw new ArgumentNullException("connectionString"); using (SqlConnection connection = new SqlConnection(connectionString)) return GetSpParameterSetInternal(connection, spname, includereturnvalueparameter); /// Retrieves the set of SqlParameters appropriate for the stored procedure /// This method will query the database for this information, and then store it in a cache for future requests. /// <param name="connection">a valid SqlConnection object</param> /// <param name="spname">the name of the stored procedure</param> /// <returns>an array of SqlParameters</returns> internal static SqlParameter[] GetSpParameterSet(SqlConnection connection, string spname) return GetSpParameterSet(connection, spname, false);
/// Retrieves the set of SqlParameters appropriate for the stored procedure /// This method will query the database for this information, and then store it in a cache for future requests. /// <param name="connection">a valid SqlConnection object</param> /// <param name="spname">the name of the stored procedure</param> /// <param name="includereturnvalueparameter">a bool value indicating whether the return value parameter should be included in the results</param> /// <returns>an array of SqlParameters</returns> internal static SqlParameter[] GetSpParameterSet(SqlConnection connection, string spname, bool includereturnvalueparameter) if (connection == null) throw new ArgumentNullException("connection"); using (SqlConnection clonedconnection = (SqlConnection)((ICloneable)connection).Clone()) return GetSpParameterSetInternal(clonedConnection, spname, includereturnvalueparameter); /// Retrieves the set of SqlParameters appropriate for the stored procedure /// <param name="connection">a valid SqlConnection object</param> /// <param name="spname">the name of the stored procedure</param> /// <param name="includereturnvalueparameter">a bool value indicating whether the return value parameter should be included in the results</param> /// <returns>an array of SqlParameters</returns> private static SqlParameter[] GetSpParameterSetInternal(SqlConnection connection, string spname, bool includereturnvalueparameter) if (connection == null) throw new ArgumentNullException("connection"); string hashkey = connection.connectionstring + ":" + spname + (includereturnvalueparameter? ":include ReturnValue Parameter" : ""); SqlParameter[] cachedparameters; cachedparameters = paramcache[hashkey] as SqlParameter[]; if (cachedparameters == null)
SqlParameter[] spparameters = DiscoverSpParameterSet(connection, spname, includereturnvalueparameter); paramcache[hashkey] = spparameters; cachedparameters = spparameters; return CloneParameters(cachedParameters); #endregion Parameter Discovery Functions