sqlhelper.cs

C#数据库类。

			{
				return ExecuteNonQueryReturnValue(connection, CommandType.StoredProcedure, spName, outParamName, (SqlParameter[])null);
			}
		}

		/// <summary>
		/// 执行一个带事务的 存储过程 或 SQL 命令，返回指定 Output 参数的值
		/// </summary>
		/// <param name="transaction">SqlTransaction</param>
		/// <param name="commandType">CommandType</param>
		/// <param name="commandText">the stored procedure name or T-SQL command</param>
		/// <param name="outParamName">返回参数的名称</param>
		/// <param name="parameterValues">an array of SqlParamters used to execute the command</param>
		/// <returns>返回参数值</returns>
		public static object ExecuteNonQueryReturnValue(SqlTransaction transaction,CommandType commandType,string commandText, string outParamName, params object[] parameterValues)
		{
			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( commandText == null || commandText.Length == 0 ) throw new ArgumentNullException( "commandText" );
			
			if ((parameterValues != null) && (parameterValues.Length > 0)) 
			{
				SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, commandText);
				
				AssignParameterValues(commandParameters, parameterValues);

				return ExecuteNonQueryReturnValue(transaction.Connection, commandType, commandText, outParamName, commandParameters);
			}
			else
			{
				return ExecuteNonQueryReturnValue(transaction.Connection, commandType, commandText, outParamName, (SqlParameter[])null);
			}
		}
		#endregion ExecuteNonQueryReturnValue

		#region ExecuteNonQueryReturnArray
		/// <summary>
		/// 执行一个 Sql 命令，返回指定 Output 参数数组
		/// </summary>
		/// <param name="connectionString">数据库链接字符串</param>
		/// <param name="commandType">指定如何解释命令字符串。(stored procedure, text, etc.)</param>
		/// <param name="commandText">要对数据源执行的 Transact-SQL 语句或存储过程</param>
		/// <param name="outParamNameList">返回参数的名称数组</param>
		/// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
		/// <returns>返回参数数组</returns>
		public static object[] ExecuteNonQueryReturnArray(string connectionString, CommandType commandType, string commandText,string[] outParamNameList, params SqlParameter[] commandParameters) 
		{
			if( connectionString == null || connectionString.Length == 0 ) throw new ArgumentNullException( "connectionString" );
			using (SqlConnection connection = new SqlConnection(connectionString))
			{
				connection.Open();
				return ExecuteNonQueryReturnArray(connection,commandType,commandText,outParamNameList,commandParameters);
			}	
		}
		/// <summary>
		/// 执行一个 Sql 命令，返回指定 Output 参数数组
		/// </summary>
		/// <param name="connection">SqlConnection</param>
		/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
		/// <param name="commandText">the stored procedure name or T-SQL command</param>
		/// <param name="outParamNameList">返回参数的名称数组</param>
		/// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
		/// <returns>返回object数组</returns>
		public static object[] ExecuteNonQueryReturnArray(SqlConnection connection, CommandType commandType, string commandText,string[] outParamNameList, params SqlParameter[] commandParameters)
		{
			int returnCount = outParamNameList.Length;
			object[] returnArray = new object[returnCount];
			using (SqlCommand cmd = new SqlCommand())
			{
				bool mustCloseConnection = false;
				PrepareCommand(cmd, connection, null, commandType, commandText, commandParameters, out mustCloseConnection );
				for(int iParam = 0; iParam < returnCount; iParam++)
				{
					string outParamName = outParamNameList[iParam];
					if(!cmd.Parameters.Contains(outParamName))
					{
						throw new ArgumentException ("SqlCommand 不包含此参数 " + outParamName);
					}	
					if(cmd.Parameters[outParamName].Direction == ParameterDirection.Output ||
						cmd.Parameters[outParamName].Direction == ParameterDirection.InputOutput)
					{
						
					}
					else throw new ArgumentException ("参数 " + outParamName + " 不是输出参数");
				}		
		
				int val = cmd.ExecuteNonQuery();

				for(int iParam = 0; iParam < returnCount; iParam++)
				{
					string outParamName = outParamNameList[iParam];
					returnArray[iParam] = cmd.Parameters [outParamName].Value;
				}

				cmd.Parameters.Clear();
				if( mustCloseConnection )
				{
					connection.Close();
				}
				return returnArray;
			}
		}
				
		/// <summary>
		/// 执行一个 存储过程 命令，返回指定 Output 参数数组
		/// </summary>
		/// <param name="connectionString">a valid connection string for a SqlConnection</param>
		/// <param name="spName">存储过程名</param>
		/// <param name="outParamNameList">返回参数的名称数组</param>
		/// <param name="parameterValues">an array of SqlParamters used to execute the command</param>
		/// <returns>返回object数组</returns>
		public static object[] ExecuteNonQueryReturnArray(string connectionString, string spName, string[] outParamNameList, params object[] parameterValues)
		{
			if( connectionString == null || connectionString.Length == 0 ) throw new ArgumentNullException( "connectionString" );
			if( spName == null || spName.Length == 0 ) throw new ArgumentNullException( "spName" );

			if ((parameterValues != null) && (parameterValues.Length > 0)) 
			{
				SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);

				AssignParameterValues(commandParameters, parameterValues);

				return ExecuteNonQueryReturnArray(connectionString, CommandType.StoredProcedure, spName, outParamNameList, commandParameters);
			}
			else 
			{
				return ExecuteNonQueryReturnArray(connectionString, CommandType.StoredProcedure, spName, outParamNameList, (SqlParameter[])null);
			}
		}
		/// <summary>
		/// 执行一个 存储过程 命令，返回指定 Output 参数数组
		/// </summary>
		/// <param name="connection">SqlConnection</param>
		/// <param name="spName">存储过程名</param>
		/// <param name="outParamNameList">返回参数的名称数组</param>
		/// <param name="parameterValues">an array of SqlParamters used to execute the command</param>
		/// <returns>返回object数组</returns>
		public static object[] ExecuteNonQueryReturnArray(SqlConnection connection, string spName, string[]  outParamNameList, params object[] parameterValues)
		{
			if( spName == null || spName.Length == 0 ) throw new ArgumentNullException( "spName" );

			if ((parameterValues != null) && (parameterValues.Length > 0)) 
			{
				SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);

				AssignParameterValues(commandParameters, parameterValues);

				return ExecuteNonQueryReturnArray(connection, CommandType.StoredProcedure, spName, outParamNameList, commandParameters);
			}
			else 
			{
				return ExecuteNonQueryReturnArray(connection, CommandType.StoredProcedure, spName, outParamNameList, (SqlParameter[])null);
			}
		}
		#endregion ExecuteNonQueryReturnArray
		
        #region ExecuteDataset

		/// <summary>
		/// Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
		/// the connection string. 
		/// </summary>
		/// <remarks>
		/// e.g.:  
		///  DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders");
		/// </remarks>
		/// <param name="connectionString">A valid connection string for a SqlConnection</param>
		/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
		/// <param name="commandText">The stored procedure name or T-SQL command</param>
		/// <returns>A dataset containing the resultset generated by the command</returns>
		public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText)
		{
			// Pass through the call providing null for the set of SqlParameters
			return ExecuteDataset(connectionString, commandType, commandText, (SqlParameter[])null);
		}

		/// <summary>
		/// Execute a SqlCommand (that returns a resultset) against the database specified in the connection string 
		/// using the provided parameters.
		/// </summary>
		/// <remarks>
		/// e.g.:  
		///  DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
		/// </remarks>
		/// <param name="connectionString">A valid connection string for a SqlConnection</param>
		/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
		/// <param name="commandText">The stored procedure name or T-SQL command</param>
		/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
		/// <returns>A dataset containing the resultset generated by the command</returns>
		public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
		{
			if( connectionString == null || connectionString.Length == 0 ) throw new ArgumentNullException( "connectionString" );

			// Create & open a SqlConnection, and dispose of it after we are done
			using (SqlConnection connection = new SqlConnection(connectionString))
			{
				connection.Open();

				// Call the overload that takes a connection in place of the connection string
				return ExecuteDataset(connection, commandType, commandText, commandParameters);
			}
		}

		/// <summary>
		/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
		/// the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
		/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
		/// </summary>
		/// <remarks>
		/// This method provides no access to output parameters or the stored procedure's return value parameter.
		/// 
		/// e.g.:  
		///  DataSet ds = ExecuteDataset(connString, "GetOrders", 24, 36);
		/// </remarks>
		/// <param name="connectionString">A valid connection string for a SqlConnection</param>
		/// <param name="spName">The name of the stored procedure</param>
		/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
		/// <returns>A dataset containing the resultset generated by the command</returns>
		public static DataSet ExecuteDataset(string connectionString, string spName, params object[] parameterValues)
		{
			if( connectionString == null || connectionString.Length == 0 ) throw new ArgumentNullException( "connectionString" );
			if( spName == null || spName.Length == 0 ) throw new ArgumentNullException( "spName" );
			
			// If we receive parameter values, we need to figure out where they go
			if ((parameterValues != null) && (parameterValues.Length > 0)) 
			{
				// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
				SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);

				// Assign the provided values to these parameters based on parameter order
				AssignParameterValues(commandParameters, parameterValues);

				// Call the overload that takes an array of SqlParameters
				return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);
			}
			else 
			{
				// Otherwise we can just call the SP without params
				return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);
			}
		}

		/// <summary>
		/// Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection. 
		/// </summary>
		/// <remarks>
		/// e.g.:  
		///  DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders");
		/// </remarks>
		/// <param name="connection">A valid SqlConnection</param>
		/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
		/// <param name="commandText">The stored procedure name or T-SQL command</param>
		/// <returns>A dataset containing the resultset generated by the command</returns>
		public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText)
		{
			// Pass through the call providing null for the set of SqlParameters
			return ExecuteDataset(connection, commandType, commandText, (SqlParameter[])null);
		}
		
		/// <summary>
		/// Execute a SqlCommand (that returns a resultset) against the specified SqlConnection 
		/// using the provided parameters.