C# 数据操作工具类

CREATE PROCEDURE [dbo].[RecordFromPage] 
 @SelectList            VARCHAR(max),   
 @TableSource        VARCHAR(100),   
 @SearchCondition    VARCHAR(max),   
 @OrderExpression    VARCHAR(1000),   
 @PageIndex            INT = 1,      
 @PageSize            INT = 10,   
 @TotalCount int output
AS 
BEGIN
    IF @SelectList IS NULL OR LTRIM(RTRIM(@SelectList)) = ''
    BEGIN
        SET @SelectList = '*'
    END
    PRINT @SelectList
    
    SET @SearchCondition = ISNULL(@SearchCondition,'')
    SET @SearchCondition = LTRIM(RTRIM(@SearchCondition))
    IF @SearchCondition <> ''
    BEGIN
        IF UPPER(SUBSTRING(@SearchCondition,1,5)) <> 'WHERE'
        BEGIN
            SET @SearchCondition = 'WHERE ' + @SearchCondition
        END
    END
    PRINT @SearchCondition

    SET @OrderExpression = ISNULL(@OrderExpression,'')
    SET @OrderExpression = LTRIM(RTRIM(@OrderExpression))
    IF @OrderExpression <> ''
    BEGIN
        IF UPPER(SUBSTRING(@OrderExpression,1,5)) <> 'WHERE'
        BEGIN
            SET @OrderExpression = 'ORDER BY ' + @OrderExpression
        END
    END
    PRINT @OrderExpression

    IF @PageIndex IS NULL OR @PageIndex < 1
    BEGIN
        SET @PageIndex = 1
    END
    PRINT @PageIndex
    IF @PageSize IS NULL OR @PageSize < 1
    BEGIN
        SET @PageSize = 10
    END
    PRINT  @PageSize
	
	DECLARE @Total int 
		DECLARE @Sql nVarchar(max)
		SET @Sql=(N'SELECT @Total=Count(*) FROM ' + @TableSource +' '+ @SearchCondition)
		print @sql
		Exec sp_executesql @Sql, N'@Total Int Out',@Total Out 
	set @TotalCount=@Total
    DECLARE @SqlQuery VARCHAR(max)

    SET @SqlQuery='SELECT '+@SelectList+',RowNumber 
    FROM 
        (SELECT ' + @SelectList + ',ROW_NUMBER() OVER( '+ @OrderExpression +') AS RowNumber 
          FROM '+@TableSource+' '+ @SearchCondition +') AS RowNumberTableSource 
    WHERE RowNumber BETWEEN ' + CAST(((@PageIndex - 1)* @PageSize+1) AS VARCHAR) 
    + ' AND ' + 
    CAST((@PageIndex * @PageSize) AS VARCHAR)
--    ORDER BY ' + @OrderExpression
    PRINT @SqlQuery
    SET NOCOUNT ON
    EXECUTE(@SqlQuery)
    SET NOCOUNT OFF
 
END

　　

/// <summary>
/// 查询接口
 /// </summary>
public interface IQuery
{
        string Column { get; set; }                                 //列名
        string TableName { get; set; }                              //表名
        string OrderBy { get; set; }                                //查询的"OrderBy"语句，不包含OrderBy，例子：ID DESC
        string BulidQuery();                                        //查询的"where"语句
        string BulidSelect(string where, string tableName = "");     //查语句
}

/// <summary>
    /// 分页实现简单查询
    /// </summary>
    public class CommonPageSql
    {


        /// <summary>
        /// 分页获取数据列表 适用于SQL2005和SQL2008
        /// </summary>
        /// <param name="con">数据库连接字符串</param>
        /// <param name="pageindex">页索引 从0开始</param>
        /// <param name="pagesize">每页记录数</param>
        /// <param name="query">查询接口</param>
        /// <param name="p">输出参数</param>
        /// <returns>DataRead数据集</returns>
        public static IDataReader GetDataReaderByPager(string con, int pageindex, int pagesize, IQuery query, out SqlParameter p)
        {
            string cmd = "RecordFromPage";
            SqlParameter[] para = SqlHelperParameterCache.GetSpParameterSet(con, cmd);
            para[0].Value = query.Column;
            para[1].Value = query.TableName;
            para[2].Value = query.BulidQuery();
            para[3].Value = query.OrderBy;
            para[4].Value = pageindex;
            para[5].Value = pagesize;
            para[6].Direction = ParameterDirection.Output;
            //SqlParameter[] para = new SqlParameter[7];
            //para[0] = new SqlParameter("@SelectList", query.Column);
            //para[1] = new SqlParameter("@TableSource", query.TableName);
            //para[2] = new SqlParameter("@SearchCondition", query.BulidQuery());
            //para[3] = new SqlParameter("@OrderExpression", query.OrderBy);
            //para[4] = new SqlParameter("@pageindex", pageindex);
            //para[5] = new SqlParameter("@pagesize", pagesize);
            //para[6] = new SqlParameter("@TotalCount", SqlDbType.Int);
            //para[6].Direction = ParameterDirection.Output;
            IDataReader reader = SqlHelper.ExecuteReader(con, CommandType.StoredProcedure, cmd, para);
            p = para[6];
            return reader;
        }

        /// <summary>
        /// 分页获取数据列表 适用于SQL2005和SQL2008
        /// </summary>
        /// <param name="con">数据库连接字符串</param>
        /// <param name="pageindex">页索引 从0开始</param>
        /// <param name="pagesize">每页记录数</param>
        /// <param name="query">查询接口</param>
        /// <param name="p">输出参数</param>
        /// <returns>DataTable数据集</returns>
        public static DataTable GetDataByPager(string con, int pageindex, int pagesize, IQuery query, out SqlParameter p)
        {
            string cmd = "RecordFromPage";
            SqlParameter[] para = SqlHelperParameterCache.GetSpParameterSet(con, cmd);
            para[0].Value = query.Column;
            para[1].Value = query.TableName;
            para[2].Value = query.BulidQuery();
            para[3].Value = query.OrderBy;
            para[4].Value = pageindex;
            para[5].Value = pagesize;
            para[6].Direction = ParameterDirection.Output;
            DataTable datatable = SqlHelper.ExecuteDataset(con,CommandType.StoredProcedure,cmd,para).Tables[0];
            p = para[6];
            return datatable;
        }
    }

/// <summary>
    /// 简单查询帮助类
    /// </summary>
    public class CommonSelectSql
    {
        #region DataReader
        /// <summary>
        /// 获取数据
        /// </summary>
        /// <param name="con">数据库连接字符串</param>
        /// <param name="top">前几条</param>
        /// <param name="Query">查询构建类</param>
        /// <returns>DataReader数据表</returns>
        public static IDataReader SelectGetReader(string con,int top,IQuery Query)
        {
            return GetDataReader(con,top, Query.TableName, Query.Column, Query.BulidQuery(), Query.OrderBy);
        }

        /// <summary>
        /// 获得前几行数据
        /// </summary>
        /// <param name="connstring">数据库连接字符串</param>
        /// <param name="Top">几条记录</param>
        /// <param name="tableName">表名</param>
        /// <param name="Column">列名</param>
        /// <param name="strWhere">查询条件</param>
        /// <param name="filedOrder">排序方式</param>
        /// <returns>DataReader数据表</returns>
        private static IDataReader GetDataReader(string connstring,int Top, string tableName, string Column, string strWhere, string filedOrder)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.AppendFormat("SELECT * FROM(SELECT ROW_NUMBER() OVER(ORDER BY {0}) ROWNUM,", filedOrder);
            if (!string.IsNullOrEmpty(Column))
            {
                strSql.Append(Column);
            }
            else
            {
                strSql.Append("*");
            }
            strSql.Append(" FROM " + tableName);
            if (strWhere.Trim() != "")
            {
                strSql.Append(" where " + strWhere + ") T");
            }
            else
            {
                strSql.Append(") T");
            }
            if (Top > 0)
            {
                strSql.AppendFormat(" WHERE T.ROWNUM <= {0}",Top);
            }
            return SqlHelper.ExecuteReader(connstring, CommandType.Text, strSql.ToString());
        }
        #endregion

        #region DataTable

        /// <summary>
        /// 获取数据
        /// </summary>
        /// <param name="con">数据库连接字符串</param>
        /// <param name="top">前几条</param>
        /// <param name="Query">查询构建类</param>
        /// <returns>DataTable数据表</returns>
        public static DataTable SelectGetTable(string con, int top, IQuery Query)
        {
            return GetDataTable(con, top, Query.TableName, Query.Column, Query.BulidQuery(), Query.OrderBy);
        }

        /// <summary>
        /// 获得前几行数据
        /// </summary>
        /// <param name="con">数据库连接字符串</param>
        /// <param name="Top">几条记录</param>
        /// <param name="tableName">表名</param>
        /// <param name="Column">列名</param>
        /// <param name="strWhere">查询条件</param>
        /// <param name="filedOrder">排序方式</param>
        /// <returns>DataTable数据表</returns>
        private static DataTable GetDataTable(string con,int Top, string tableName, string Column, string strWhere, string filedOrder)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("select ");
            if (Top > 0)
            {
                strSql.Append(" top " + Top.ToString());
            }
            strSql.Append(Column);
            strSql.Append(" FROM " + tableName);
            if (strWhere.Trim() != "")
            {
                strSql.Append(" where " + strWhere);
            }
            strSql.Append(" order by " + filedOrder);
            return SqlHelper.ExecuteDataset(con,CommandType.Text,strSql.ToString()).Tables[0];
        }
        #endregion
    }

/// <summary>
    /// 用来缓存SqlParameter
    /// </summary>
    public sealed class SqlHelperParameterCache
    {
        #region 私有方法，变量，跟构造函数

        private SqlHelperParameterCache() { }

        private static Hashtable paramCache = Hashtable.Synchronized(new Hashtable());

        /// <summary>
        /// 返回存储过程中的参数信息
        /// </summary>
        /// <param name="connection">数据库连接对象</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="includeReturnValueParameter">是否返回需要返回的参数@RETURN_VALUE</param>
        /// <returns>返回的参数数组.</returns>
        private static SqlParameter[] DiscoverSpParameterSet(SqlConnection connection, string spName, bool includeReturnValueParameter)
        {
            if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("存储过程名");

            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);

            foreach (SqlParameter discoveredParameter in discoveredParameters)
            {
                discoveredParameter.Value = DBNull.Value;
            }
            return discoveredParameters;
        }

        /// <summary>
        /// 复制一份参数数组
        /// </summary>
        /// <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

        #region 缓存方法

        /// <summary>
        /// 将参数数组添加到缓存
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</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;
        }

        /// <summary>
        /// 从缓存里获取参数数组
        /// </summary>
        /// <param name="connectionString">一个有效的数据库连接字符串</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <returns>参数数组</returns>
        public static SqlParameter[] GetCachedParameterSet(string connectionString, string commandText)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("没有提供数据库连接字符串");
            if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("没有提供存储过程的名字或者 T-SQL 语句");

            string hashKey = connectionString + ":" + commandText;

            SqlParameter[] cachedParameters = paramCache[hashKey] as SqlParameter[];
            if (cachedParameters == null)
            {
                return null;
            }
            else
            {
                return CloneParameters(cachedParameters);
            }
        }

        #endregion caching functions

        #region 获取参数

        /// <summary>
        /// 通过存储过程名跟连接字符串获取缓存中的参数数组
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="spName">存储过程名</param>
        /// <returns>参数数组</returns>
        public static SqlParameter[] GetSpParameterSet(string connectionString, string spName)
        {
            return GetSpParameterSet(connectionString, spName, false);
        }

        /// <summary>
        /// 通过存储过程名跟连接字符串获取缓存中的参数数组
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="includeReturnValueParameter">是否返回输出参数</param>
        /// <returns>参数数组</returns>
        public static SqlParameter[] GetSpParameterSet(string connectionString, string spName, bool includeReturnValueParameter)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("没有提供数据库连接字符串");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程名");

            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                return GetSpParameterSetInternal(connection, spName, includeReturnValueParameter);
            }
        }

        /// <summary>
        /// 通过数据库连接对象获取缓存中的参数数组
        /// </summary>
        /// <param name="connection">数据库连接对象</param>
        /// <param name="spName">存储过程名</param>
        /// <returns>参数数组</returns>
        internal static SqlParameter[] GetSpParameterSet(SqlConnection connection, string spName)
        {
            return GetSpParameterSet(connection, spName, false);
        }

        /// <summary>
        /// 通过数据库连接对象获取缓存中的参数数组
        /// </summary>
        /// <param name="connection">数据库连接对象</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="includeReturnValueParameter">是否返回输出参数</param>
        /// <returns>参数数组</returns>
        internal static SqlParameter[] GetSpParameterSet(SqlConnection connection, string spName, bool includeReturnValueParameter)
        {
            if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
            using (SqlConnection clonedConnection = (SqlConnection)((ICloneable)connection).Clone())
            {
                return GetSpParameterSetInternal(clonedConnection, spName, includeReturnValueParameter);
            }
        }

        /// <summary>
        /// 通过数据库连接对象获取缓存中的参数数组
        /// </summary>
        /// <param name="connection">数据库连接对象</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="includeReturnValueParameter">是否返回输出参数</param>
        /// <returns>参数数组</returns>
        private static SqlParameter[] GetSpParameterSetInternal(SqlConnection connection, string spName, bool includeReturnValueParameter)
        {
            if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程名");

            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



    }

/// <summary>
    /// 封装数据库操作方法
    /// </summary>
    public abstract class SqlHelper
    {
        #region 私有方法以及构造方法

        //不允许建立实例
        private SqlHelper() { }

        //获取数据库连接
        public static SqlConnection GetSqlConnection(string con)
        {

            try
            {
                return new SqlConnection(con);
            }
            catch
            {
                throw new Exception("连接出错");
            }

        }


        /// <summary>
        /// 这个方法给SqlCommand添加参数
        /// </summary>
        /// <param name="command">需要添加参数的command</param>
        /// <param name="commandParameters">参数数组</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)
                    {
                        // 检查当为输入参数时赋予默认值
                        if ((p.Direction == ParameterDirection.InputOutput ||
                            p.Direction == ParameterDirection.Input) &&
                            (p.Value == null))
                        {
                            p.Value = DBNull.Value;
                        }
                        command.Parameters.Add(p);
                    }
                }
            }
        }

        /// <summary>
        /// 这个方法使用的DataRow列的值填充SqlParameter数组
        /// </summary>
        /// <param name="commandParameters">需要填充到SqlParameter数组的DataRow</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(
                        "没有给SqlParameter赋予ParameterName");
                if (dataRow.Table.Columns.IndexOf(commandParameter.ParameterName.Substring(1)) != -1)
                    commandParameter.Value = dataRow[commandParameter.ParameterName.Substring(1)];
                i++;
            }
        }

        /// <summary>
        /// 给SqlParameter数组赋值
        /// </summary>
        /// <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("SqlParameter数组的长度跟参数值的数组的长度不匹配");
            }

            // 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++)
            {
                // 如果目前的数组值来自IDbDataParameter 则填充
                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>
        /// 为执行sql命令做准备
        /// </summary>
        /// <param name="command">sql指令</param>
        /// <param name="connection">数据库连接</param>
        /// <param name="transaction">数据库事务</param>
        /// <param name="commandType">指令类型</param>
        /// <param name="commandText">sql语句或存储过程</param>
        /// <param name="commandParameters">执行sql需要传入的参数</param>
        /// <param name="mustCloseConnection">如果sql连接还没有关闭着返回true</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("缺少SqlCommand参数");
            if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("缺少sql语句或存储过程语句");

            //当数据库没有连接则连接
            if (connection.State != ConnectionState.Open)
            {
                mustCloseConnection = true;
                connection.Open();
            }
            else
            {
                mustCloseConnection = true;
            }
            command.Connection = connection;
            command.CommandText = commandText;

            if (transaction != null)
            {
                if (transaction.Connection == null) throw new ArgumentException("请提供一个已经打开的事务", "transaction");
                command.Transaction = transaction;
            }
            command.CommandType = commandType;

            if (commandParameters != null)
            {
                AttachParameters(command, commandParameters);
            }
            return;
        }

        #endregion

        #region ExecuteNonQuery

        /// <summary>
        ///执行的SqlCommand （返回结果并没有任何参数）
        /// </summary>
        /// <param name="connectionString">一个有效的数据库连接字符串</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
        public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText)
        {
            return ExecuteNonQuery(connectionString, commandType, commandText, (SqlParameter[])null);
        }

        /// <summary>
        ///执行的SqlCommand （没有返回结果）
        /// </summary>
        /// <param name="connectionString">一个有效的数据库连接字符串</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
        public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("没有提供数据库连接字符串");
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();
                return ExecuteNonQuery(connection, commandType, commandText, commandParameters);
            }
        }

        /// <summary>
        /// 执行存储过程通过的SqlCommand （没有返回结果）
        /// </summary>
        /// <param name="connectionString">一个有效的数据库连接字符串</param>
        /// <param name="spName">存储过程名称</param>
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
        public static int ExecuteNonQuery(string connectionString, string spName, params object[] parameterValues)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("没有提供数据库连接字符串");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程名");
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
                AssignParameterValues(commandParameters, parameterValues);
                return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        /// 执行的SqlCommand （返回结果并没有任何参数）。 
        /// </summary>
        /// <param name="connection">SqlConnection连接</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</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>
        /// 执行的SqlCommand （返回结果并没有任何参数）
        /// </summary>
        /// <param name="connection">一个现有的数据库连接</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
        public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            if (connection == null) throw new ArgumentNullException("没有提供现有的数据库连接");
            SqlCommand cmd = new SqlCommand();
            bool mustCloseConnection = true;
            PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
            int retval = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            if (mustCloseConnection)
                connection.Close();
            return retval;
        }

        /// <summary>
        ///执行存储过程通过的SqlCommand （没有返回结果）
        /// </summary>
        /// <param name="connection">一个现有的数据库连接</param>
        /// <param name="spName">存储过程名称</param>
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
        public static int ExecuteNonQuery(SqlConnection connection, string spName, params object[] parameterValues)
        {
            if (connection == null) throw new ArgumentNullException("没有提供现有的数据库连接");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("存储过程的名字");
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
                AssignParameterValues(commandParameters, parameterValues);
                return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        /// 执行的SqlCommand （没有返回结果并没有任何参数）对所提供的SqlTransaction 。
        /// </summary>
        /// <param name="transaction">事务</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <returns>A返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
        public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText)
        {
            return ExecuteNonQuery(transaction, commandType, commandText, (SqlParameter[])null);
        }

        /// <summary>
        /// 执行的SqlCommand （没有返回结果）对所提供的SqlTransaction 。
        /// </summary>
        /// <param name="transaction">事务</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</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("请为提供SqlTransaction提供连接", "transaction");
            SqlCommand cmd = new SqlCommand();
            bool mustCloseConnection = true;
            PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
            int retval = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return retval;
        }

        /// <summary>
        /// 执行的SqlCommand （没有返回结果）对所提供的SqlTransaction 
        /// </summary>
        /// <param name="transaction">事务</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</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("请为提供SqlTransaction提供连接", "transaction");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("请提供存储过程名");

            if ((parameterValues != null) && (parameterValues.Length > 0))
            {

                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);
            }
        }

        #endregion ExecuteNonQuery

        #region ExecuteDataset

        /// <summary>
        /// 执行的SqlCommand （即返回一个结果，并没有任何参数）
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <returns>返回结果集DataSet</returns>
        public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText)
        {
            return ExecuteDataset(connectionString, commandType, commandText, (SqlParameter[])null);
        }

        /// <summary>
        /// 执行的SqlCommand （即返回一个结果）
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回结果集DataSet</returns>
        public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString参数没有提供");
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();
                return ExecuteDataset(connection, commandType, commandText, commandParameters);
            }
        }

        /// <summary>
        /// 使用存储过程执行的SqlCommand （即返回一个结果）.
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回结果集DataSet</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("没有提供存储过程名");

            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
                AssignParameterValues(commandParameters, parameterValues);
                return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        /// 执行的SqlCommand （即返回一个结果，并没有任何参数）
        /// </summary>
        /// <param name="connection">数据库连接对象</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <returns>返回结果集DataSet</returns>
        public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText)
        {
            return ExecuteDataset(connection, commandType, commandText, (SqlParameter[])null);
        }

        /// <summary>
        /// 执行的SqlCommand （即返回一个结果）
        /// </summary>
        /// <param name="connection">数据库连接对象</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回结果集DataSet</returns>
        public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            if (connection == null) throw new ArgumentNullException("没有提供SqlConnection对象");

            SqlCommand cmd = new SqlCommand();
            bool mustCloseConnection = true;
            cmd.CommandTimeout = connection.ConnectionTimeout;
            PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);

            using (SqlDataAdapter da = new SqlDataAdapter(cmd))
            {
                DataSet ds = new DataSet();
                da.Fill(ds);
                cmd.Parameters.Clear();

                if (mustCloseConnection)
                    connection.Close();
                return ds;
            }
        }

        /// <summary>
        /// 使用存储过程执行的SqlCommand （即返回一个结果）.
        /// </summary>
        /// <param name="connection">数据库连接对象</param>
        /// <param name="spName">存储过程的名</param>
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回结果集DataSet</returns>
        public static DataSet ExecuteDataset(SqlConnection connection, string spName, params object[] parameterValues)
        {
            if (connection == null) throw new ArgumentNullException("没有提供SqlConnection对象");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程名");
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
                AssignParameterValues(commandParameters, parameterValues);
                return ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteDataset(connection, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        /// 执行的SqlCommand （即返回一个结果，没有任何参数）对所提供的SqlTransaction 。
        /// </summary>
        /// <param name="transaction">事务</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <returns>返回结果集DataSet</returns>
        public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText)
        {
            return ExecuteDataset(transaction, commandType, commandText, (SqlParameter[])null);
        }

        /// <summary>
        /// 执行的SqlCommand （即返回一个结果）对所提供的SqlTransaction 。
        /// </summary>
        /// <param name="transaction">事务</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回结果集DataSet</returns>
        public static DataSet ExecuteDataset(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("没有提供一个打开的transaction.", "transaction");

            SqlCommand cmd = new SqlCommand();
            bool mustCloseConnection = true;
            PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);

            using (SqlDataAdapter da = new SqlDataAdapter(cmd))
            {
                DataSet ds = new DataSet();
                da.Fill(ds);
                cmd.Parameters.Clear();
                return ds;
            }
        }

        /// <summary>
        /// 使用存储过程执行的SqlCommand （即返回一个结果）对所提供的SqlTransaction 。.
        /// </summary>
        /// <param name="transaction">事务</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回结果集DataSet</returns>
        public static DataSet ExecuteDataset(SqlTransaction transaction, string spName, params object[] parameterValues)
        {
            if (transaction == null) throw new ArgumentNullException("没有提供transaction");
            if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供一个打开的transaction.", "transaction");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程名");

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

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteDataset(transaction, CommandType.StoredProcedure, spName);
            }
        }

        #endregion ExecuteDataset

        #region ExecuteReader

        /// <summary>
        /// 这个枚举用来表是把数据库连接对象交给sqlHelper来处理还是调用者自己进行处理
        /// </summary>
        private enum SqlConnectionOwnership
        {
            /// <summary>SqlHelper来处理</summary>
            Internal,
            /// <summary>调用者自行处理</summary>
            External
        }

        /// <summary>
        /// 执行的SqlCommand （即返回一个只读结果）
        /// </summary>
        /// <param name="connection">一个有效的SqlConnection </param>
        /// <param name="transaction">一个有效的SqlTransaction,可以为null</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <param name="connectionOwnership">sqlHelper来处理还是调用者自己进行处理数据库连接对象</param>
        /// <returns>返回一个只读结果</returns>
        private static SqlDataReader ExecuteReader(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters, SqlConnectionOwnership connectionOwnership)
        {
            if (connection == null) throw new ArgumentNullException("没有提供SqlConnection对象");

            bool mustCloseConnection = true;
            SqlCommand cmd = new SqlCommand();
            cmd.CommandTimeout = 180;
            try
            {
                PrepareCommand(cmd, connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
                SqlDataReader dataReader;

                if (connectionOwnership == SqlConnectionOwnership.External)
                {
                    dataReader = cmd.ExecuteReader();
                }
                else
                {
                    dataReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                }
                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;
            }
        }

        /// <summary>
        /// 执行的SqlCommand （即返回一个只读结果，没有参数）
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <returns>返回一个只读结果</returns>
        public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText)
        {
            return ExecuteReader(connectionString, commandType, commandText, (SqlParameter[])null);
        }

        /// <summary>
        /// 执行的SqlCommand （即返回一个只读结果）
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个只读结果</returns>
        public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("没有提供数据库连接字符串");
            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;
            }

        }

        /// <summary>
        /// 使用存储过程执行SqlCommand （即返回一个只读结果）
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个只读结果</returns>
        public static SqlDataReader ExecuteReader(string connectionString, string spName, params object[] parameterValues)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("没有提供数据库连接字符串");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程名");

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

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteReader(connectionString, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        /// 执行的SqlCommand （即返回一个只读结果，没有参数）
        /// </summary>
        /// <param name="connection">一个有效的SqlConnection </param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <returns>返回一个只读结果</returns>
        public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText)
        {
            return ExecuteReader(connection, commandType, commandText, (SqlParameter[])null);
        }

        /// <summary>
        /// 执行的SqlCommand （即返回一个只读结果）
        /// </summary>
        /// <param name="connection">一个有效的SqlConnection</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个只读结果</returns>
        public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            return ExecuteReader(connection, (SqlTransaction)null, commandType, commandText, commandParameters, SqlConnectionOwnership.External);
        }

        /// <summary>
        /// 使用存储过程执行SqlCommand （即返回一个只读结果）
        /// </summary>
        /// <param name="connection">一个有效的SqlConnection</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个只读结果</returns>
        public static SqlDataReader ExecuteReader(SqlConnection connection, string spName, params object[] parameterValues)
        {
            if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程名");

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

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteReader(connection, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        /// 执行的SqlCommand （即返回一个只读结果，没有传入的参数）对所提供的SqlTransaction 。.
        /// </summary>
        /// <param name="transaction">一个有效的SqlTransaction</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <returns>返回一个只读结果</returns>
        public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText)
        {
            return ExecuteReader(transaction, commandType, commandText, (SqlParameter[])null);
        }

        /// <summary>
        /// 执行的SqlCommand （即返回一个只读结果）对所提供的SqlTransaction 。
        /// </summary>
        /// <param name="transaction">一个有效的SqlTransaction</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个只读结果</returns>
        public static SqlDataReader ExecuteReader(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("没有提供一个打开的transaction.", "transaction");

            return ExecuteReader(transaction.Connection, transaction, commandType, commandText, commandParameters, SqlConnectionOwnership.External);
        }

        /// <summary>
        /// 使用存储过程执行的SqlCommand （即返回一个只读结果）对所提供的SqlTransaction 。
        /// </summary>
        /// <param name="transaction">一个有效的SqlTransaction</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个只读结果</returns>
        public static SqlDataReader ExecuteReader(SqlTransaction transaction, string spName, params object[] parameterValues)
        {
            if (transaction == null) throw new ArgumentNullException("没有提供transaction");
            if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供一个打开的transaction.", "transaction");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("存储过程");

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

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteReader(transaction, CommandType.StoredProcedure, spName);
            }
        }

        #endregion ExecuteReader

        #region ExecuteScalar

        /// <summary>
        /// 执行的SqlCommand （即返回第一行第一列，不带参数）
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <returns>返回数据库中第一行第一列的数据</returns>
        public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText)
        {
            return ExecuteScalar(connectionString, commandType, commandText, (SqlParameter[])null);
        }

        /// <summary>
        /// 执行的SqlCommand （即返回第一行第一列）
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回数据库中第一行第一列的数据</returns>
        public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("没有提供数据库连接字符串");
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();
                return ExecuteScalar(connection, commandType, commandText, commandParameters);
            }
        }

        /// <summary>
        /// 使用存储过程执行的SqlCommand （即返回第一行第一列）
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回数据库中第一行第一列的数据</returns>
        public static object ExecuteScalar(string connectionString, string spName, params object[] parameterValues)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("没有提供数据库连接字符串");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("存储过程名");

            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
                AssignParameterValues(commandParameters, parameterValues);
                return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        ///执行的SqlCommand （即返回第一行第一列,不带参数）
        /// </summary>
        /// <param name="connection">有效的数据库连接</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <returns>返回数据库中第一行第一列的数据</returns>
        public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText)
        {
            return ExecuteScalar(connection, commandType, commandText, (SqlParameter[])null);
        }

        /// <summary>
        /// 有效的数据库连接
        /// </summary>
        /// <param name="connection">有效的数据库连接</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回数据库中第一行第一列的数据</returns>
        public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
            SqlCommand cmd = new SqlCommand();

            bool mustCloseConnection = true;
            PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
            object retval = cmd.ExecuteScalar();

            cmd.Parameters.Clear();

            if (mustCloseConnection)
                connection.Close();

            return retval;
        }

        /// <summary>
        /// 使用存储过程执行的SqlCommand （即返回第一行第一列）
        /// </summary>
        /// <param name="connection">有效的数据库连接</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回数据库中第一行第一列的数据</returns>
        public static object ExecuteScalar(SqlConnection connection, string spName, params object[] parameterValues)
        {
            if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程");

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

                AssignParameterValues(commandParameters, parameterValues);
                return ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteScalar(connection, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        /// 执行SqlCommand （即返回第一行第一列，不带参数）对所提供的SqlTransaction 。
        /// </summary>
        /// <param name="transaction">一个有效的SqlTransaction</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <returns>返回数据库中第一行第一列的数据</returns>
        public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText)
        {
            return ExecuteScalar(transaction, commandType, commandText, (SqlParameter[])null);
        }

        /// <summary>
        /// 执行SqlCommand （即返回第一行第一列）对所提供的SqlTransaction 。
        /// </summary>
        /// <param name="transaction">一个有效的SqlTransaction</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回数据库中第一行第一列的数据</returns>
        public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
            if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供一个打开的transaction", "transaction");

            SqlCommand cmd = new SqlCommand();
            bool mustCloseConnection = true;
            PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
            object retval = cmd.ExecuteScalar();

            cmd.Parameters.Clear();
            return retval;
        }

        /// <summary>
        /// 使用存储过程执行的SqlCommand （即返回第一行第一列）对所提供的SqlTransaction 。
        /// </summary>
        /// <param name="transaction">一个有效的SqlTransaction</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回数据库中第一行第一列的数据</returns>
        public static object ExecuteScalar(SqlTransaction transaction, string spName, params object[] parameterValues)
        {
            if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
            if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供一个打开的transaction", "transaction");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("存储过程名");

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

                AssignParameterValues(commandParameters, parameterValues);
                return ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteScalar(transaction, CommandType.StoredProcedure, spName);
            }
        }

        #endregion ExecuteScalar

        #region ExecuteXmlReader
        /// <summary>
        /// 执行的SqlCommand （即返回一个XmlReader，并没有任何参数）对所提供的SqlConnection 。
        /// </summary>
        /// <param name="connection">有效的数据库连接</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <returns>返回的xmlReader对象</returns>
        public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText)
        {
            return ExecuteXmlReader(connection, commandType, commandText, (SqlParameter[])null);
        }

        /// <summary>
        ///  执行的SqlCommand （即返回一个XmlReader）对所提供的SqlConnection 。
        /// </summary>
        /// <param name="connection">有效的数据库连接</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回的xmlReader对象</returns>
        public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            if (connection == null) throw new ArgumentNullException("没有提供SqlConnection对象");

            bool mustCloseConnection = true;
            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;
            }
        }

        /// <summary>
        /// 使用存储过程执行的SqlCommand （即返回一个XmlReader）对所提供的SqlConnection 。
        /// </summary>
        /// <param name="connection">有效的数据库连接</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回的xmlReader对象</returns>
        public static XmlReader ExecuteXmlReader(SqlConnection connection, string spName, params object[] parameterValues)
        {
            if (connection == null) throw new ArgumentNullException("没有提供SqlConnection对象");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("存储过程名");

            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
                AssignParameterValues(commandParameters, parameterValues);
                return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        /// 执行SqlCommand （即返回第一行第一列，不带参数）对所提供的SqlTransaction 。
        /// </summary>
        /// <param name="transaction">一个有效的SqlTransaction</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <returns>返回的xmlReader对象</returns>
        public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText)
        {
            return ExecuteXmlReader(transaction, commandType, commandText, (SqlParameter[])null);
        }

        /// <summary>
        /// 执行SqlCommand （即返回第一行第一列）对所提供的SqlTransaction 。
        /// </summary>
        /// <param name="transaction">一个有效的SqlTransaction</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回的xmlReader对象</returns>
        public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
            if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供一个打开的transaction", "transaction");
            SqlCommand cmd = new SqlCommand();
            bool mustCloseConnection = true;
            PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);

            XmlReader retval = cmd.ExecuteXmlReader();

            cmd.Parameters.Clear();
            return retval;
        }

        /// <summary>
        /// 使用存储过程执行SqlCommand （即返回第一行第一列）对所提供的SqlTransaction 。
        /// </summary>
        /// <param name="transaction">一个有效的SqlTransaction</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回的xmlReader对象</returns>
        public static XmlReader ExecuteXmlReader(SqlTransaction transaction, string spName, params object[] parameterValues)
        {
            if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
            if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供一个打开的transaction", "transaction");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("存储过程");

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

                AssignParameterValues(commandParameters, parameterValues);
                return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName);
            }
        }

        #endregion ExecuteXmlReader

        #region FillDataset
        /// <summary>
        /// 执行的SqlCommand （即返回一个DataSet，并没有任何参数）
        /// </summary>
        /// <param name="connectionString">数据库连接对象字符串</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="dataSet">一个DataSet ，其中将载有结果</param>
        /// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称（可能是实际的表名称）</param>
        public static void FillDataset(string connectionString, CommandType commandType, string commandText, DataSet dataSet, string[] tableNames)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("缺少数据库连接字符串");
            if (dataSet == null) throw new ArgumentNullException("dataSet不能为null");

            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();
                FillDataset(connection, commandType, commandText, dataSet, tableNames);
            }
        }

        /// <summary>
        /// 执行的SqlCommand （即返回一个DataSet）
        /// </summary>
        /// <param name="connectionString">数据库连接对象字符串</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <param name="dataSet">一个DataSet ，其中将载有结果</param>
        /// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称（可能是实际的表名称）
        /// </param>
        public static void FillDataset(string connectionString, CommandType commandType,
            string commandText, DataSet dataSet, string[] tableNames,
            params SqlParameter[] commandParameters)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("缺少数据库连接字符串");
            if (dataSet == null) throw new ArgumentNullException("dataSet不能为null");
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();
                FillDataset(connection, commandType, commandText, dataSet, tableNames, commandParameters);
            }
        }

        /// <summary>
        /// 使用存储过程执行的SqlCommand （即返回一个DataSet）
        /// </summary>
        /// <param name="connectionString">数据库连接对象字符串</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="dataSet">一个DataSet ，其中将载有结果</param>
        /// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称（可能是实际的表名称）
        /// </param>    
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        public static void FillDataset(string connectionString, string spName,
            DataSet dataSet, string[] tableNames,
            params object[] parameterValues)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("缺少数据库连接字符串");
            if (dataSet == null) throw new ArgumentNullException("dataSet不能为null");

            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();

                FillDataset(connection, spName, dataSet, tableNames, parameterValues);
            }
        }

        /// <summary>
        /// 执行的SqlCommand （即返回一个DataSet，不带参数）
        /// </summary>
        /// <param name="connection">数据库连接对象</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="dataSet">一个DataSet ，其中将载有结果</param>
        /// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称（可能是实际的表名称）
        /// </param>    
        public static void FillDataset(SqlConnection connection, CommandType commandType,
            string commandText, DataSet dataSet, string[] tableNames)
        {
            FillDataset(connection, commandType, commandText, dataSet, tableNames, null);
        }

        /// <summary>
        /// 执行的SqlCommand （即返回一个DataSet）
        /// </summary>
        /// <param name="connection">数据库连接对象</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="dataSet">一个DataSet ，其中将载有结果</param>
        /// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称（可能是实际的表名称）
        /// </param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        public static void FillDataset(SqlConnection connection, CommandType commandType,
            string commandText, DataSet dataSet, string[] tableNames,
            params SqlParameter[] commandParameters)
        {
            FillDataset(connection, null, commandType, commandText, dataSet, tableNames, commandParameters);
        }

        /// <summary>
        /// 执行的SqlCommand （即返回一个DataSet）
        /// </summary>
        /// <param name="connection">数据库连接对象</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="dataSet">一个DataSet ，其中将载有结果</param>
        /// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称（可能是实际的表名称）
        /// </param>
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        public static void FillDataset(SqlConnection connection, string spName,
            DataSet dataSet, string[] tableNames,
            params object[] parameterValues)
        {
            if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
            if (dataSet == null) throw new ArgumentNullException("dataSet不能为null");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("存储过程名");


            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
                AssignParameterValues(commandParameters, parameterValues);
                FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames, commandParameters);
            }
            else
            {
                FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames);
            }
        }

        /// <summary>
        /// 执行SqlCommand （即返回一个DataSet，不带参数）对所提供的SqlTransaction 。
        /// </summary>
        /// <param name="transaction">有效的SqlTransaction对象</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="dataSet">一个DataSet ，其中将载有结果</param>
        /// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称（可能是实际的表名称）
        /// </param>
        public static void FillDataset(SqlTransaction transaction, CommandType commandType,
            string commandText,
            DataSet dataSet, string[] tableNames)
        {
            FillDataset(transaction, commandType, commandText, dataSet, tableNames, null);
        }

        /// <summary>
        /// 执行SqlCommand （即返回一个DataSet）对所提供的SqlTransaction 。
        /// </summary>
        /// <param name="transaction">有效的SqlTransaction对象</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="dataSet">一个DataSet ，其中将载有结果</param>
        /// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称（可能是实际的表名称）
        /// </param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        public static void FillDataset(SqlTransaction transaction, CommandType commandType,
            string commandText, DataSet dataSet, string[] tableNames,
            params SqlParameter[] commandParameters)
        {
            FillDataset(transaction.Connection, transaction, commandType, commandText, dataSet, tableNames, commandParameters);
        }

        /// <summary>
        /// 使用存储过程执行SqlCommand （即返回一个DataSet）对所提供的SqlTransaction 。
        /// </summary>
        /// <param name="transaction">有效的SqlTransaction对象</param>
        /// <param name="spName">存储过程</param>
        /// <param name="dataSet">一个DataSet ，其中将载有结果</param>
        /// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称（可能是实际的表名称）
        /// </param>
        /// <param name="parameterValues">以数组形式提供SqlCommand命令中用到的参数列表</param>
        public static void FillDataset(SqlTransaction transaction, string spName,
            DataSet dataSet, string[] tableNames,
            params object[] parameterValues)
        {
            if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
            if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供一个打开的transaction", "transaction");
            if (dataSet == null) throw new ArgumentNullException("dataSet不能为null");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("存储过程名");

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

                FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames, commandParameters);
            }
            else
            {
                FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames);
            }
        }

        /// <summary>
        /// 私有方法，执行的SqlCommand （即返回一个结果集）对指定的SqlTransaction和SqlConnection使用提供的参数。
        /// </summary>
        /// <param name="connection">数据库连接对象</param>
        /// <param name="transaction">有效的SqlTransaction对象</param>
        /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="dataSet">一个DataSet ，其中将载有结果</param>
        /// <param name="tableNames">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称（可能是实际的表名称）
        /// </param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        private static void FillDataset(SqlConnection connection, SqlTransaction transaction, CommandType commandType,
            string commandText, DataSet dataSet, string[] tableNames,
            params SqlParameter[] commandParameters)
        {
            if (connection == null) throw new ArgumentNullException("没有提供SqlConnection对象");
            if (dataSet == null) throw new ArgumentNullException("dataSet不能为null");

            SqlCommand command = new SqlCommand();
            bool mustCloseConnection = true;
            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("该tableNames参数必须包含一个表格中的字段，这里提供了一个值为空或空字符串.", "tableNames");
                        dataAdapter.TableMappings.Add(tableName, tableNames[index]);
                        tableName += (index + 1).ToString();
                    }
                }

                dataAdapter.Fill(dataSet);
                command.Parameters.Clear();
            }

            if (mustCloseConnection)
                connection.Close();
        }
        #endregion

        #region UpdateDataset
        /// <summary>
        /// 执行各自的命令为每个插入，更新或删除的行中的数据。
        /// </summary>

        /// <param name="insertCommand">插入的SqlCommand</param>
        /// <param name="deleteCommand">删除的SqlCommand</param>
        /// <param name="updateCommand">更新的SqlCommand</param>
        /// <param name="dataSet">一个DataSet ，其中将载有结果</param>
        /// <param name="tableName">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称（可能是实际的表名称）</param>
        public static void UpdateDataset(SqlCommand insertCommand, SqlCommand deleteCommand, SqlCommand updateCommand, DataSet dataSet, string tableName)
        {
            if (insertCommand == null) throw new ArgumentNullException("没有提供插入的SqlCommand");
            if (deleteCommand == null) throw new ArgumentNullException("没有提供删除的SqlCommand");
            if (updateCommand == null) throw new ArgumentNullException("没有提供更新的SqlCommand");
            if (tableName == null || tableName.Length == 0) throw new ArgumentNullException("没有提供tableName");

            using (SqlDataAdapter dataAdapter = new SqlDataAdapter())
            {
                dataAdapter.UpdateCommand = updateCommand;
                dataAdapter.InsertCommand = insertCommand;
                dataAdapter.DeleteCommand = deleteCommand;

                dataAdapter.Update(dataSet, tableName);

                dataSet.AcceptChanges();
            }
        }
        #endregion

        #region CreateCommand
        /// <summary>
        /// 简化建立一个SQL命令对象，允许存储过程和可选的参数
        /// </summary>
        /// <param name="connection">有效的SqlConnection对象</param>
        /// <param name="spName">存储过程</param>
        /// <param name="sourceColumns">该数组将被用于创建表映射允许DataTables被引用的用户定义的名称（可能是实际的表名称）</param>
        /// <returns>sql命令对象</returns>
        public static SqlCommand CreateCommand(SqlConnection connection, string spName, params string[] sourceColumns)
        {
            if (connection == null) throw new ArgumentNullException("没有提供SqlConnection对象");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("存储过程名");

            SqlCommand cmd = new SqlCommand(spName, connection);
            cmd.CommandType = CommandType.StoredProcedure;

            if ((sourceColumns != null) && (sourceColumns.Length > 0))
            {

                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);

                for (int index = 0; index < sourceColumns.Length; index++)
                    commandParameters[index].SourceColumn = sourceColumns[index];

                AttachParameters(cmd, commandParameters);
            }

            return cmd;
        }
        #endregion

        #region ExecuteNonQueryTypedParams
        /// <summary>
        /// 执行存储过程通过的SqlCommand （没有返回结果）使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库，发现参数的存储过程（第一次每一个存储过程被称为） ，并指定值的基础上连续值。
        /// </summary>
        /// <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)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("没有提供数据库连接字符串");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程名");

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

                AssignParameterValues(commandParameters, dataRow);

                return SqlHelper.ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return SqlHelper.ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        /// 执行存储过程通过的SqlCommand （没有返回结果）使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库，发现参数的存储过程（第一次每一个存储过程被称为） ，并指定值的基础上连续值。
        /// </summary>
        /// <param name="connection">有效的SqlConnection对象</param>
        /// <param name="spName">存储过程</param>
        /// <param name="dataRow">储存参数值的DataRow.</param>
        /// <returns>返回更新的行数</returns>
        public static int ExecuteNonQueryTypedParams(SqlConnection connection, String spName, DataRow dataRow)
        {
            if (connection == null) throw new ArgumentNullException("没有提供SqlConnection对象");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程");

            if (dataRow != null && dataRow.ItemArray.Length > 0)
            {

                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);

                AssignParameterValues(commandParameters, dataRow);

                return SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        /// 执行存储过程通过的SqlCommand （没有返回结果）使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库，发现参数的存储过程（第一次每一个存储过程被称为） ，并指定值的基础上连续值。
        /// </summary>
        /// <param name="transaction">有效的SqlTransaction对象</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="dataRow">储存参数值的DataRow</param>
        /// <returns>返回更新的行数</returns>
        public static int ExecuteNonQueryTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
        {
            if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
            if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供有连接的SqlTransaction对象", "transaction");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程");

            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);
            }
            else
            {
                return SqlHelper.ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);
            }
        }
        #endregion

        #region ExecuteDatasetTypedParams
        /// <summary>
        ///执行预存程序通过的SqlCommand （返回DataSet）使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库，发现参数的存储过程（第一次每一个存储过程被称为） ，并指定值的基础上连续值。
        /// </summary>
        /// <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)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("没有提供数据库连接字符串");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程");

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

                AssignParameterValues(commandParameters, dataRow);

                return SqlHelper.ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return SqlHelper.ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        /// 执行预存程序通过的SqlCommand （返回DataSet）使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库，发现参数的存储过程（第一次每一个存储过程被称为） ，并指定值的基础上连续值。
        /// </summary>
        /// <param name="connection">有效的SqlConnection对象</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="dataRow">储存参数值的DataRow</param>
        /// <returns>返回结果集Dataset</returns>
        public static DataSet ExecuteDatasetTypedParams(SqlConnection connection, String spName, DataRow dataRow)
        {
            if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程");

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

                AssignParameterValues(commandParameters, dataRow);

                return SqlHelper.ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return SqlHelper.ExecuteDataset(connection, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        /// 执行预存程序通过的SqlCommand （返回DataSet）使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库，发现参数的存储过程（第一次每一个存储过程被称为） ，并指定值的基础上连续值。
        /// </summary>
        /// <param name="transaction">有效的SqlTransaction对象</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="dataRow">储存参数值的DataRow</param>
        /// <returns>返回结果集Dataset</returns>
        public static DataSet ExecuteDatasetTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
        {
            if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
            if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供有连接的SqlTransaction对象", "transaction");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程");


            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);
            }
            else
            {
                return SqlHelper.ExecuteDataset(transaction, CommandType.StoredProcedure, spName);
            }
        }

        #endregion

        #region ExecuteReaderTypedParams
        /// <summary>
        /// 执行预存程序通过的SqlCommand （返回SqlDataReader）使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库，发现参数的存储过程（第一次每一个存储过程被称为） ，并指定值的基础上连续值。
        /// </summary>
        /// <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)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("没有提供数据库连接字符串");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程");

            if (dataRow != null && dataRow.ItemArray.Length > 0)
            {

                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);

                AssignParameterValues(commandParameters, dataRow);

                return SqlHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return SqlHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, spName);
            }
        }


        /// <summary>
        /// 执行预存程序通过的SqlCommand （返回SqlDataReader）使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库，发现参数的存储过程（第一次每一个存储过程被称为） ，并指定值的基础上连续值。
        /// </summary>
        /// <param name="connection">有效的SqlConnection对象</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="dataRow">储存参数值的DataRow</param>
        /// <returns>返回结果集SqlDataReader</returns>
        public static SqlDataReader ExecuteReaderTypedParams(SqlConnection connection, String spName, DataRow dataRow)
        {
            if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程");

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

                AssignParameterValues(commandParameters, dataRow);

                return SqlHelper.ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return SqlHelper.ExecuteReader(connection, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        /// 执行预存程序通过的SqlCommand （返回SqlDataReader）使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库，发现参数的存储过程（第一次每一个存储过程被称为） ，并指定值的基础上连续值。
        /// </summary>
        /// <param name="transaction">有效的SqlTransaction对象</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="dataRow">储存参数值的DataRow</param>
        /// <returns>返回结果集SqlDataReader</returns>
        public static SqlDataReader ExecuteReaderTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
        {
            if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
            if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供有连接的SqlTransaction对象.", "transaction");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程");

            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);
            }
            else
            {
                return SqlHelper.ExecuteReader(transaction, CommandType.StoredProcedure, spName);
            }
        }
        #endregion

        #region ExecuteScalarTypedParams
        /// <summary>
        /// 执行预存程序通过的SqlCommand （返回第一行第一列）使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库，发现参数的存储过程（第一次每一个存储过程被称为） ，并指定值的基础上连续值。
        /// </summary>
        /// <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)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("没有提供数据库连接字符串");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程");

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

                AssignParameterValues(commandParameters, dataRow);

                return SqlHelper.ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return SqlHelper.ExecuteScalar(connectionString, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        /// 执行预存程序通过的SqlCommand （返回第一行第一列）使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库，发现参数的存储过程（第一次每一个存储过程被称为） ，并指定值的基础上连续值。
        /// </summary>
        /// <param name="connection">有效的SqlConnection对象</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="dataRow">储存参数值的DataRow</param>
        /// <returns>返回第一行第一列</returns>
        public static object ExecuteScalarTypedParams(SqlConnection connection, String spName, DataRow dataRow)
        {
            if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程");

            if (dataRow != null && dataRow.ItemArray.Length > 0)
            {

                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
                AssignParameterValues(commandParameters, dataRow);

                return SqlHelper.ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return SqlHelper.ExecuteScalar(connection, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        /// 执行预存程序通过的SqlCommand （返回第一行第一列）使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库，发现参数的存储过程（第一次每一个存储过程被称为） ，并指定值的基础上连续值。
        /// </summary>
        /// <param name="transaction">有效的SqlTransaction对象</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="dataRow">储存参数值的DataRow.</param>
        /// <returns>返回第一行第一列</returns>
        public static object ExecuteScalarTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
        {
            if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
            if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供有连接的SqlTransaction对象", "transaction");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程");

            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);
            }
            else
            {
                return SqlHelper.ExecuteScalar(transaction, CommandType.StoredProcedure, spName);
            }
        }
        #endregion

        #region ExecuteXmlReaderTypedParams
        /// <summary>
        /// 执行预存程序通过的SqlCommand （返回XmlReader）使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库，发现参数的存储过程（第一次每一个存储过程被称为） ，并指定值的基础上连续值。
        /// </summary>
        /// <param name="connection">有效的SqlConnection对象</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="dataRow">储存参数值的DataRow.</param>
        /// <returns>返回XmlReader</returns>
        public static XmlReader ExecuteXmlReaderTypedParams(SqlConnection connection, String spName, DataRow dataRow)
        {
            if (connection == null) throw new ArgumentNullException("没有提供数据库连接对象");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程");

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

                return SqlHelper.ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return SqlHelper.ExecuteXmlReader(connection, CommandType.StoredProcedure, spName);
            }
        }

        /// <summary>
        /// 执行预存程序通过的SqlCommand （返回XmlReader）使用的DataRow列的值的存储过程的参数值。这种方法将查询数据库，发现参数的存储过程（第一次每一个存储过程被称为） ，并指定值的基础上连续值。
        /// </summary>
        /// <param name="transaction">有效的SqlTransaction对象</param>
        /// <param name="spName">存储过程名</param>
        /// <param name="dataRow">储存参数值的DataRow.</param>
        /// <returns>返回XmlReader</returns>
        public static XmlReader ExecuteXmlReaderTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
        {
            if (transaction == null) throw new ArgumentNullException("没有提供SqlTransaction对象");
            if (transaction != null && transaction.Connection == null) throw new ArgumentException("没有提供有连接的SqlTransaction对象.", "transaction");
            if (spName == null || spName.Length == 0) throw new ArgumentNullException("没有提供存储过程");

            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);
            }
            else
            {
                return SqlHelper.ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName);
            }
        }
        #endregion

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="connectionString">多条SQL语句</param>    
        /// <param name="SQLStringList">多条SQL语句</param>    
        /// <returns>影响的记录数</returns>
        public static int ExecuteSqlTran(string connectionString, List<String> SQLStringList)
        {
            using (SqlConnection conn = new SqlConnection(connectionString))
            {
                conn.Open();
                SqlCommand cmd = new SqlCommand();
                cmd.Connection = conn;
                SqlTransaction tx = conn.BeginTransaction();
                cmd.Transaction = tx;
                try
                {
                    int count = 0;
                    for (int n = 0; n < SQLStringList.Count; n++)
                    {
                        string strsql = SQLStringList[n];
                        if (strsql.Trim().Length > 1)
                        {
                            cmd.CommandText = strsql;
                            count += cmd.ExecuteNonQuery();
                        }
                    }
                    tx.Commit();
                    return count;
                }
                catch
                {
                    tx.Rollback();
                    return 0;
                }
            }
        }


        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="connectionString">泛型列</param>
        /// <param name="SQLStringList">泛型列</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSqlTran(string connectionString, List<CommandInfo> cmdList)
        {
            using (SqlConnection conn = new SqlConnection(connectionString))
            {
                conn.Open();
                using (SqlTransaction trans = conn.BeginTransaction())
                {
                    SqlCommand cmd = new SqlCommand();
                    cmd.Connection = conn;
                    cmd.Transaction = trans;
                    int count = 0;
                    //循环
                    foreach (CommandInfo myDE in cmdList)
                    {
                        cmd.Parameters.Clear();
                        cmd.CommandText = myDE.CommandText;
                        cmd.CommandType = myDE.CommandType;
                        AttachParameters(cmd, myDE.Parameters);
                        try
                        {
                            int result = cmd.ExecuteNonQuery();
                            count += result;
                        }
                        catch
                        {
                            trans.Rollback();
                            return 0;
                        }
                    }
                    trans.Commit();
                    return count;

                }
            }
        }

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="connectionString">泛型列</param>
        /// <param name="SQLStringList">泛型列</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSqlTranWithException(string connectionString, List<CommandInfo> cmdList)
        {
            using (SqlConnection conn = new SqlConnection(connectionString))
            {
                conn.Open();
                using (SqlTransaction trans = conn.BeginTransaction())
                {
                    SqlCommand cmd = new SqlCommand();
                    cmd.Connection = conn;
                    cmd.Transaction = trans;
                    int count = 0;
                    //循环
                    foreach (CommandInfo myDE in cmdList)
                    {
                        cmd.Parameters.Clear();
                        cmd.CommandText = myDE.CommandText;
                        cmd.CommandType = myDE.CommandType;
                        AttachParameters(cmd, myDE.Parameters);
                        try
                        {
                            int result = cmd.ExecuteNonQuery();
                            count += result;
                        }
                        catch (Exception ex)
                        {
                            trans.Rollback();
                            throw;
                        }
                    }
                    trans.Commit();
                    return count;

                }
            }
        }

        ///<summary>
        ///直接通过DataSet更新数据库表
        ///</summary>
        ///<param name="ds"></param>
        ///<param name="strTblName">ds中要更新的表名</param>
        ///<param name="strConnection"></param>
        ///<returns></returns>
        public static int UpdateByDataSet(DataSet ds, string strTblName, string strConnection)
        {

            SqlConnection conn = new SqlConnection(strConnection);

            SqlDataAdapter myAdapter = new SqlDataAdapter();
            SqlCommand myCommand = new SqlCommand("select  * from " + strTblName, conn);
            myAdapter.SelectCommand = myCommand;
            SqlCommandBuilder myCommandBuilder = new SqlCommandBuilder(myAdapter);
            return myAdapter.Update(ds, strTblName);
        }

        /// <summary>
        /// 判断reader里是否存在列名
        /// </summary>
        /// <param name="reader"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        public static bool ContainsField(IDataReader reader, string name)
        {
            for (int i = 0; i < reader.FieldCount; i++)
            {
                if (reader.GetName(i) == name)
                    return true;
            }

            return false;
        }

    }

 

public class CommandInfo
    {
        private string _commandText;
        private CommandType _commandType;

        public CommandType CommandType
        {
            get { return _commandType; }
            set { _commandType = value; }
        }
        public string CommandText
        {
            get { return _commandText; }
            set { _commandText = value; }
        }
        private SqlParameter[] _parameters;

        public SqlParameter[] Parameters
        {
            get { return _parameters; }
            set { _parameters = value; }
        }

        public CommandInfo(string sqlText, SqlParameter[] para, CommandType ct)
        {
            _commandText = sqlText;
            _parameters = para;
            _commandType = ct;
        }
    }

 

转载于:https://www.cnblogs.com/Darker-Samuel/p/5909265.html