开源asp.net三层结构之数据层！

Question

using System;
using System.Data;
using System.Configuration;
using System.Xml;
using System.Data.SqlClient;
using System.Collections;namespace EVeip.DataAccess
{
/// <summary>
/// 数据访问层，提供处理Sql Server 2000数据库的各种方法
/// </summary>
public sealed class Database
{
#region private utility methods & constructors // Since this class provides only static methods, make the default constructor private to prevent 
// instances from being created with "new Database()"
private Database() {} /// <summary>
/// 取回连接字符串
/// </summary>
public static string ConnectionString
{
get {return ConfigurationSettings.AppSettings["ConnectionString"] ;}
} /// <summary>
/// This method is used to attach array of SqlParameters to a SqlCommand.
/// 
/// This method will assign a value of DbNull to any parameter with a direction of
/// InputOutput and a value of null.  
/// 
/// This behavior will prevent default values from being used, but
/// this will be the less common case than an intended pure output parameter (derived as InputOutput)
/// where the user provided no input value.
/// </summary>
/// <param name="command">The command to which the parameters will be added</param>
/// <param name="commandParameters">An array of SqlParameters to be added to command</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);
}
}
}
} /// <summary>
/// This method assigns dataRow column values to an array of SqlParameters
/// </summary>
/// <param name="commandParameters">Array of SqlParameters to be assigned values</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values</param>

Answer 1

private static void AssignParameterValues(SqlParameter[] commandParameters, DataRow dataRow)
{
if ((commandParameters == null) || (dataRow == null)) 
{
// Do nothing if we get no data
return;
} int i = 0;
// Set the parameters values
foreach(SqlParameter commandParameter in commandParameters)
{
// Check the parameter name
if( commandParameter.ParameterName == null || 
commandParameter.ParameterName.Length <= 1 )
throw new Exception( 
string.Format( 
"Please provide a valid parameter name on the parameter #{0}, the ParameterName property has the following value: '{1}'.", 
i, commandParameter.ParameterName ) );
if (dataRow.Table.Columns.IndexOf(commandParameter.ParameterName.Substring(1)) != -1)
commandParameter.Value = dataRow[commandParameter.ParameterName.Substring(1)];
i++;
}
} /// <summary>
/// This method assigns an array of values to an array of SqlParameters
/// </summary>
/// <param name="commandParameters">Array of SqlParameters to be assigned values</param>
/// <param name="parameterValues">Array of objects holding the values to be assigned</param>
public static void AssignParameterValues(SqlParameter[] commandParameters,params object[] parameterValues)
{
if ((commandParameters == null) || (parameterValues == null)) 
{
// Do nothing if we get no data
return;
} // We must have the same number of values as we pave parameters to put them in
if (commandParameters.Length != parameterValues.Length)
{
throw new ArgumentException("Parameter count does not match Parameter Value count.");
} // Iterate through the SqlParameters, assigning the values from the corresponding position in the 
// value array
for (int i = 0, j = commandParameters.Length; i < j; i++)
{
// If the current array value derives from IDbDataParameter, then assign its Value property
if (parameterValues[i] is IDbDataParameter)
{
IDbDataParameter paramInstance = (IDbDataParameter)parameterValues[i];
if( paramInstance.Value == null )
{
commandParameters[i].Value = DBNull.Value; 
}
else
{
commandParameters[i].Value = paramInstance.Value;
}
}
else if (parameterValues[i] == null)
{
commandParameters[i].Value = DBNull.Value;
}
else
{
commandParameters[i].Value = parameterValues[i];
}
}
} /// <summary>
/// This method opens (if necessary) and assigns a connection, transaction, command type and parameters 
/// to the provided command
/// </summary>
/// <param name="command">The SqlCommand to be prepared</param>
/// <param name="connection">A valid SqlConnection, on which to execute this command</param>
/// <param name="transaction">A valid SqlTransaction, or 'null'</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 SqlParameters to be associated with the command or 'null' if no parameters are required</param>
/// <param name="mustCloseConnection"><c>true</c> if the connection was opened by the method, otherwose is 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 the provided connection is not open, we will open it
if (connection.State != ConnectionState.Open)
{
mustCloseConnection = true;
connection.Open();
}
else
{
mustCloseConnection = false;
} // Associate the connection with the command
command.Connection = connection; // Set the command text (stored procedure name or SQL statement)
command.CommandText = commandText; // If we were provided a transaction, assign it
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;
} // Set the command type
command.CommandType = commandType; // Attach the command parameters if they are provided
if (commandParameters != null)
{
AttachParameters(command, commandParameters);
}
return;
} #endregion private utility methods & constructors #region ExecuteNonQuery /// <summary>
/// Execute a SqlCommand (that returns no resultset and takes no parameters) against the database specified in 
/// the connection string
/// </summary>
/// <res>
/// e.g.:  
///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders");
/// </res>
/// <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>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of SqlParameters
return ExecuteNonQuery(connectionString, commandType, commandText, (SqlParameter[])null);
} /// <summary>
/// Execute a SqlCommand (that returns no resultset) against the database specified in the connection string 
/// using the provided parameters
/// </summary>
/// <res>
/// e.g.:  
///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
/// </res>
/// <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>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(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 ExecuteNonQuery(connection, commandType, commandText, commandParameters);
}
}

Answer 2

/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns no 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>
/// <res>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// 
/// e.g.:  
///  int result = ExecuteNonQuery(connString, "PublishOrders", 24, 36);
/// </res>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="spName">The name of the stored prcedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(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 = ParamsCache.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 ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
else 
{
// Otherwise we can just call the SP without params
return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// Execute a SqlCommand (that returns no resultset and takes no parameters) against the provided SqlConnection. 
/// </summary>
/// <res>
/// e.g.:  
///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders");
/// </res>
/// <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>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of SqlParameters
return ExecuteNonQuery(connection, commandType, commandText, (SqlParameter[])null);
} /// <summary>
/// Execute a SqlCommand (that returns no resultset) against the specified SqlConnection 
/// using the provided parameters.
/// </summary>
/// <res>
/// e.g.:  
///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
/// </res>
/// <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>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
if( connection == null ) throw new ArgumentNullException( "connection" ); // Create a command and prepare it for execution
SqlCommand cmd = new SqlCommand();
bool mustCloseConnection = false;
PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection );
    
// Finally, execute the command
int retval = cmd.ExecuteNonQuery();
    
// Detach the SqlParameters from the command object, so they can be used again
cmd.Parameters.Clear();
if( mustCloseConnection )
connection.Close();
return retval;
} /// <summary>
/// Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified SqlConnection 
/// 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>
/// <res>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// 
/// e.g.:  
///  int result = ExecuteNonQuery(conn, "PublishOrders", 24, 36);
/// </res>
/// <param name="connection">A valid 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>An int representing the number of rows affected by the command</returns>

Answer 3

public static int ExecuteNonQuery(SqlConnection connection, string spName, params object[] parameterValues)
{
if( connection == null ) throw new ArgumentNullException( "connection" );
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 = ParamsCache.GetSpParameterSet(connection, 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 ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else 
{
// Otherwise we can just call the SP without params
return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);
}
} /// <summary>
/// Execute a SqlCommand (that returns no resultset and takes no parameters) against the provided SqlTransaction. 
/// </summary>
/// <res>
/// e.g.:  
///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders");
/// </res>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of SqlParameters
return ExecuteNonQuery(transaction, commandType, commandText, (SqlParameter[])null);
} /// <summary>
/// Execute a SqlCommand (that returns no resultset) against the specified SqlTransaction
/// using the provided parameters.
/// </summary>
/// <res>
/// e.g.:  
///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
/// </res>
/// <param name="transaction">A valid SqlTransaction</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>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
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" ); // Create a command and prepare it for execution
SqlCommand cmd = new SqlCommand();
bool mustCloseConnection = false;
PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection );
    
// Finally, execute the command
int retval = cmd.ExecuteNonQuery();
    
// Detach the SqlParameters from the command object, so they can be used again
cmd.Parameters.Clear();
return retval;
} /// <summary>
/// Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified 
/// SqlTransaction 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>
/// <res>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// 
/// e.g.:  
///  int result = ExecuteNonQuery(conn, trans, "PublishOrders", 24, 36);
/// </res>
/// <param name="transaction">A valid SqlTransaction</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>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(SqlTransaction transaction, string spName, 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( 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 = ParamsCache.GetSpParameterSet(transaction.Connection, 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 ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else 
{
// Otherwise we can just call the SP without params
return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);
}
} #endregion ExecuteNonQuery #region ExecuteDataset /// <summary>
/// Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
/// the connection string. 
/// </summary>
/// <res>
/// e.g.:  
///  DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders");
/// </res>
/// <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);
}

Answer 4

自己写了一个功能类似SqlHelper的东西,意义大么?