封装sqlserver类 俩个

----------------------------------------------------------------------------------------------------------------

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Data.SqlClient;
    /// <summary>
    /// MySqlHelper 的摘要说明
    /// </summary>
    public class MySqlHelper
    {

        //private SqlConnection Conn;
        private SqlCommand Comm;
        private SqlDataAdapter da;
        private DataSet ds;
        private DataTable dt;
        private SqlDataReader dr;
        private SqlTransaction trans;
        public static string ConnString = ConfigurationManager.ConnectionStrings["GBKConnectionString"].ConnectionString;

        public static SqlConnection Conn()
        {
            SqlConnection Conn = new SqlConnection(ConnString);
            return Conn;
        }
        //
        // TODO: 在此处添加构造函数逻辑
        //

        /// <summary>无参数命令或存储过程构造MySqlCommand对象</summary>
        /// <param name=commandTextOrProcedureName>Sql命令或存储过程名</param>
        /// <param name=commandType>类型(Sql命令或存储过程)</param>
        ///
        private SqlCommand buildSqlCommand(string commandTextOrProcedureName, CommandType commandType)
        {
            try
            {
                Comm = new SqlCommand(commandTextOrProcedureName, Conn());
                Comm.CommandType = commandType;
                return Comm;
            }
            catch (Exception error)
            {
                throw error;
            }
        }
        /// <summary>在新的MySqlConnection中以无参数命令或存储过程构造MySqlCommand对象</summary>
        /// <param name=commandTextOrProcedureName>Sql命令或存储过程名</param>
        /// <param name=commandType>类型(Sql命令或存储过程)</param>
        /// <param name=newConn>新的MySqlConnection对象</param>
        private SqlCommand buildSqlCommand(string commandTextOrProcedureName, CommandType commandType, SqlConnection newConn)
        {
            try
            {
                Comm = new SqlCommand(commandTextOrProcedureName, newConn);
                Comm.CommandType = commandType;
                return Comm;
            }
            catch (Exception error)
            {
                throw error;
            }
        }
        / <summary>有参数命令或存储过程构造MySqlCommand对象</summary>
        / <param name=commandTextOrProcedureName>Sql命令或存储过程名</param>
        / <param name=parameters>SqlParameter参数数组</param>
        / <param name=commandType>类型(Sql命令或存储过程)</param>
        private SqlCommand buildSqlCommand(string commandTextOrProcedureName, SqlParameter[] parameters, CommandType commandType)
        {
            try
            {
                Comm = new SqlCommand(commandTextOrProcedureName, Conn());
                Comm.CommandType = commandType;
                foreach (SqlParameter parameter in parameters)
                {
                    Comm.Parameters.Add(parameter);
                }
                return Comm;
            }
            catch (Exception error)
            {
                throw error;
            }
        }
        / <summary>在新的MySqlConnection中以有参数命令或存储过程构造MySqlCommand对象</summary>
        / <param name=commandTextOrProcedureName>Sql命令或存储过程名</param>
        / <param name=parameters>MySqlParameter参数数组</param>
        / <param name=commandType>类型(Sql命令或存储过程)</param>
        / <param name=newConn>新的MySqlConnection对象</param>
        private SqlCommand buildSqlCommand(string commandTextOrProcedureName, SqlParameter[] parameters, CommandType commandType, SqlConnection newConn)
        {
            try
            {
                Comm = new SqlCommand(commandTextOrProcedureName, newConn);
                Comm.CommandType = commandType;
                foreach (SqlParameter parameter in parameters)
                {
                    Comm.Parameters.Add(parameter);
                }
                return Comm;
            }
            catch (Exception error)
            {
                throw error;
            }
        }
        ///**/
        / <summary>执行无参数查询命令或存储过程,返回第一行第一列的值</summary>
        / <param name=commandTextOrProcedureName>Sql命令或存储过程名</param>
        / <param name=commandType>类型(Sql命令或存储过程)</param>
        / <param name=isNewConnection>是否使用新的连接执行</param>
        / <returns>返回第一行第一列的值,如果结果为null则返回空字符串</returns>
        private string ExecuteScalar(string commandTextOrProcedureName, CommandType commandType, bool isNewConnection)
        {
            string result = "";
            if (isNewConnection)
            {
                using (SqlConnection newConn = new SqlConnection(MySqlHelper.ConnString))
                {
                    try
                    {
                        Comm = new SqlCommand(commandTextOrProcedureName, newConn);
                        newConn.Open();
                        if (Comm.ExecuteScalar() != null)
                            result = Comm.ExecuteScalar().ToString();
                    }
                    catch (Exception error)
                    {
                        throw error;
                    }
                    finally
                    {
                        newConn.Close();
                    }
                }
            }
            else
            {
                try
                {
                    if (Conn().State == ConnectionState.Closed)
                    {
                        Conn().Open();
                    }
                    Comm = this.buildSqlCommand(commandTextOrProcedureName, commandType);
                    if (Comm.ExecuteScalar() != null)
                        result = Comm.ExecuteScalar().ToString();
                }
                catch (Exception error)
                {
                    throw error;
                }
                finally
                {
                    Conn().Close();
                }
                return result;
            }
            return result;
        }
        ///**/
        / <summary>执行有参数查询命令或存储过程,返回第一行第一列的值</summary>
        / <param name=commandTextOrProcedureName>Sql命令或存储过程名</param>
        / <param name=parameters>SqlParameter参数数组</param>
        / <param name=commandType>类型(Sql命令或存储过程)</param>
        / <param name=isNewConnection>是否使用新的连接执行</param>
        / <returns>返回第一行第一列的值,如果结果为null则返回空字符串</returns>
        protected string ExecuteScalar(string commandTextOrProcedureName, SqlParameter[] parameters, CommandType commandType, bool isNewConnection)
        {
            string result = "";
            if (isNewConnection)
            {
                using (SqlConnection newConn = new SqlConnection(MySqlHelper.ConnString))
                {
                    try
                    {
                        Comm = this.buildSqlCommand(commandTextOrProcedureName, parameters, commandType, newConn);
                        newConn.Open();
                        if (Comm.ExecuteScalar() != null)
                            result = Comm.ExecuteScalar().ToString();
                    }
                    catch (Exception error)
                    {
                        throw error;
                    }
                    finally
                    {
                        newConn.Close();
                    }
                }
            }
            else
            {
                try
                {
                    if (Conn().State == ConnectionState.Closed)
                    {
                        Conn().Open();
                    }
                    Comm = this.buildSqlCommand(commandTextOrProcedureName, parameters, commandType);
                    if (Comm.ExecuteScalar() != null)
                        result = Comm.ExecuteScalar().ToString();
                }
                catch (Exception error)
                {
                    throw error;
                }
                finally
                {
                    Conn().Close();
                }
            }
            return result;
        }
        //    /// <summary>执行无参数命令或存储过程,返回受影响行数</summary>
        //    /// <param name=commandTextOrProcedureName>Sql命令或存储过程名</param>
        //    /// <param name=commandType>类型(Sql命令或存储过程)</param>
        //    /// <param name=isNewConnection>是否使用新的连接执行</param>
        //    /// <returns>返回受影响的行数</returns>
        protected int ExecuteNonQuery(string commandTextOrProcedureName, CommandType commandType, bool isNewConnection)
        {
            int result = 0;
            if (isNewConnection)
            {
                using (SqlConnection newConn = new SqlConnection(MySqlHelper.ConnString))
                {
                    try
                    {
                        Comm = this.buildSqlCommand(commandTextOrProcedureName, commandType, newConn);
                        newConn.Open();
                        result = Comm.ExecuteNonQuery();
                    }
                    catch (Exception error)
                    {
                        throw error;
                    }
                    finally
                    {
                        newConn.Close();
                    }
                }
            }
            else
            {
                try
                {
                    if (Conn().State == ConnectionState.Closed)
                    {
                        Conn().Open();
                    }
                    Comm = this.buildSqlCommand(commandTextOrProcedureName, commandType);
                    result = Comm.ExecuteNonQuery();
                }
                catch (Exception error)
                {
                    throw error;
                }
                finally
                {
                    Conn().Close();
                }
            }
            return result;
        }
        ///**/
        / <summary>执行有参数命令或存储过程,返回受影响行数</summary>
        / <param name=commandTextOrProcedureName>Sql命令或存储过程名</param>
        / <param name=parameters>SqlParameter参数数组</param>
        / <param name=commandType>类型(Sql命令或存储过程)</param>
        / <param name=isNewConnection>是否使用新的连接执行</param>
        / <returns>返回受影响的行数</returns>
        protected int ExecuteNonQuery(string commandTextOrProcedureName, SqlParameter[] parameters, CommandType commandType, bool isNewConnection)
        {
            int result = 0;
            if (isNewConnection)
            {
                using (SqlConnection newConn = new SqlConnection(MySqlHelper.ConnString))
                {
                    try
                    {
                        Comm = this.buildSqlCommand(commandTextOrProcedureName, parameters, commandType, newConn);
                        newConn.Open();
                        result = Comm.ExecuteNonQuery();
                    }
                    catch (Exception error)
                    {
                        throw error;
                    }
                    finally
                    {
                        newConn.Close();
                    }
                }
            }
            else
            {
                try
                {
                    if (Conn().State == ConnectionState.Closed)
                    {
                        Conn().Open();
                    }
                    Comm = this.buildSqlCommand(commandTextOrProcedureName, parameters, commandType);
                    result = Comm.ExecuteNonQuery();
                }
                catch (Exception error)
                {
                    throw error;
                }
                finally
                {
                    Conn().Close();
                }
            }
            return result;
        }
        ///**/
        / <summary>执行无参数查询命令或存储过程,返回SqlDataReader对象(注意用完后及时关闭MySqlDataReader对象)</summary>
        / <param name=commandTextOrProcedureName>Sql命令或存储过程名</param>
        / <param name=commandType>类型(Sql命令或存储过程)</param>
        / <param name=isNewConnection>是否使用新的连接执行</param>
        / <returns>MySqlDataReader(当MySqlDataReader对象关闭时对应的MySqlConnection对象将关闭)</returns>
        protected SqlDataReader ExecuteReader(string commandTextOrProcedureName, CommandType commandType, bool isNewConnection)
        {
            if (isNewConnection)
            {
                try
                {
                    SqlConnection newConn = new SqlConnection(MySqlHelper.ConnString);
                    Comm = this.buildSqlCommand(commandTextOrProcedureName, commandType, newConn);
                    newConn.Open();
                    return Comm.ExecuteReader(CommandBehavior.CloseConnection);
                }
                catch (Exception error)
                {
                    throw error;
                }
            }
            else
            {
                try
                {
                    if (Conn().State == ConnectionState.Closed)
                    {
                        Conn().Open();
                    }
                    Comm = this.buildSqlCommand(commandTextOrProcedureName, commandType);
                    return Comm.ExecuteReader(CommandBehavior.CloseConnection);
                }
                catch (Exception error)
                {
                    throw error;
                }
            }
        }
        / <summary>执行有参数查询命令或存储过程,返回SqlDataReader对象(注意用完后及时关闭MySqlDataReader对象)</summary>
        / <param name=commandTextOrProcedureName>Sql命令或存储过程名</param>
        / <param name=parameters>MySqlParameter参数数组</param>
        / <param name=commandType>类型(Sql命令或存储过程)</param>
        / <param name=isNewConnection>是否使用新的连接执行</param>
        / <returns>MySqlDataReader(当MySqlDataReader对象关闭时对应的MySqlConnection对象将关闭)</returns>
        protected SqlDataReader ExecuteReader(string commandTextOrProcedureName, SqlParameter[] parameters, CommandType commandType, bool isNewConnection)
        {
            if (isNewConnection)
            {
                try
                {
                    SqlConnection newConn = new SqlConnection(MySqlHelper.ConnString);
                    Comm = this.buildSqlCommand(commandTextOrProcedureName, parameters, commandType, newConn);
                    newConn.Open();
                    return Comm.ExecuteReader(CommandBehavior.CloseConnection);
                }
                catch (Exception error)
                {
                    throw error;
                }
            }
            else
            {
                try
                {
                    if (Conn().State == ConnectionState.Closed)
                    {
                        Conn().Open();
                    }
                    Comm = this.buildSqlCommand(commandTextOrProcedureName, parameters, commandType);
                    return Comm.ExecuteReader(CommandBehavior.CloseConnection);
                }
                catch (Exception error)
                {
                    throw error;
                }
            }
        }
        / <summary>执行无参数查询命令或存储过程,返回DataSet</summary>
        / <param name=commandTextOrProcedureName>Sql命令或存储过程名</param>
        / <param name=commandType>类型(Sql命令或存储过程)</param>
        / <param name=isNewConnection>是否用新的连接执行</param>
        / <returns></returns>
        public DataSet ExecuteDataSet(string commandTextOrProcedureName, CommandType commandType, bool isNewConnection)
        {
            if (isNewConnection)
            {
                using (SqlConnection newConn = new SqlConnection(MySqlHelper.ConnString))
                {
                    try
                    {
                        newConn.Open();
                        Comm = this.buildSqlCommand(commandTextOrProcedureName, commandType, newConn);
                        da = new SqlDataAdapter(Comm);
                        ds = new DataSet();
                        da.Fill(ds);
                        return ds;
                    }
                    catch (Exception error)
                    {
                        throw error;
                    }
                    finally
                    {
                        newConn.Close();
                    }
                }
            }
            else
            {
                try
                {
                    if (Conn().State == ConnectionState.Closed)
                    {
                        Conn().Open();
                    }
                    Comm = this.buildSqlCommand(commandTextOrProcedureName, commandType);
                    da = new SqlDataAdapter(Comm);
                    ds = new DataSet();
                    da.Fill(ds);
                    return ds;
                }
                catch (Exception error)
                {
                    throw error;
                }
                finally
                {
                    Conn().Close();
                }
            }
        }
        / <summary>执行有参数查询命令或存储过程,返回DataSet</summary>
        / <param name=commandTextOrProcedureName>Sql命令或存储过程名</param>
        / <param name=parameters>SqlParameter参数数组</param>
        / <param name=commandType>类型(Sql命令或存储过程)</param>
        / <param name=isNewConnection>是否用新的连接执行</param>
        / <returns></returns>
        protected DataSet ExecuteDataSet(string commandTextOrProcedureName, SqlParameter[] parameters, CommandType commandType, bool isNewConnection)
        {
            if (isNewConnection)
            {
                using (SqlConnection newConn = new SqlConnection(MySqlHelper.ConnString))
                {
                    try
                    {
                        newConn.Open();
                        Comm = this.buildSqlCommand(commandTextOrProcedureName, parameters, commandType, newConn);
                        da = new SqlDataAdapter(Comm);
                        ds = new DataSet();
                        da.Fill(ds);
                        return ds;
                    }
                    catch (Exception error)
                    {
                        throw error;
                    }
                    finally
                    {
                        newConn.Close();
                    }
                }
            }
            else
            {
                try
                {
                    if (Conn().State == ConnectionState.Closed)
                    {
                        Conn().Open();
                    }
                    Comm = this.buildSqlCommand(commandTextOrProcedureName, parameters, commandType);
                    da = new SqlDataAdapter(Comm);
                    ds = new DataSet();
                    da.Fill(ds);
                    return ds;
                }
                catch (Exception error)
                {
                    throw error;
                }
                finally
                {
                    Conn().Close();
                }
            }
        }
        ///**/
        / <summary>
        / 事务处理
        / </summary>
        / <param name=cmdArray>MySqlCommand数组</param>
        / <param name=isNewConnection>是否使用新的连接执行</param>
        protected void ExecuteTransaction(SqlCommand[] cmdArray, bool isNewConnection)
        {
            if (isNewConnection)
            {
                using (SqlConnection newConn = new SqlConnection(MySqlHelper.ConnString))
                {
                    try
                    {
                        newConn.Open();
                        trans = newConn.BeginTransaction();
                        foreach (SqlCommand c in cmdArray)
                        {
                            c.ExecuteNonQuery();
                        }
                        trans.Commit();
                    }
                    catch (Exception error)
                    {
                        trans.Rollback();
                        throw error;
                    }
                    finally
                    {
                        newConn.Close();
                    }
                }
            }
            else
            {
                try
                {
                    if (Conn().State == ConnectionState.Closed)
                    {
                        Conn().Open();
                    }
                    trans = Conn().BeginTransaction();
                    foreach (SqlCommand c in cmdArray)
                    {
                        c.ExecuteNonQuery();
                    }
                    trans.Commit();
                }
                catch (Exception error)
                {
                    trans.Rollback();
                    throw error;
                }
                finally
                {
                    Conn().Close();
                }
            }
        }
        / <summary>执行有参数且返回值为Int型的存储过程,获取返回结果</summary>
        / <param name=commandTextOrProcedureName>存储过程名</param>
        / <param name=parameters>SqlParameter参数数组</param>
        / <returns>Int</returns>
        protected int ExecuteProcedure(string procedureName, SqlParameter[] parameters)
        {
            string ReturnValue = "";
            try
            {
                if (Conn().State == ConnectionState.Closed)
                {
                    Conn().Open();
                }
                Comm = this.buildSqlCommand(procedureName, parameters, CommandType.StoredProcedure);
                Comm.Parameters.Add(new SqlParameter(ReturnValue, SqlDbType.Int, 4, ParameterDirection.ReturnValue, false, 0, 0, String.Empty, DataRowVersion.Default, null));
                Comm.ExecuteNonQuery();
                return (int)Comm.Parameters[ReturnValue].Value;
            }
            catch (Exception error)
            {
                throw error;
            }
            finally
            {
                Conn().Close();
            }
        }
        / 执行分页存储过程,存储过程的第一个参数必须为out用于输出记录总数
        / </summary>
        / <remarks>parameters中勿使用表别名,SQL语法尽量标准</remarks>
        / <param name=rowsTotal>返回的记录总数</param>
        / <param name=procedureName>分页存储过程名称</param>
        / <param name=parameters>分页存储过程参数</param>
        / <returns></returns>
        protected DataSet ExecuteProcedure(out int rowsTotal, string procedureName, SqlParameter[] parameters)
        {
            try
            {
                if (Conn().State == ConnectionState.Closed)
                {
                    Conn().Open();
                }
                Comm = this.buildSqlCommand(procedureName, parameters, CommandType.StoredProcedure);
                ds = new DataSet();
                SqlDataAdapter da = new SqlDataAdapter(Comm);
                da.Fill(ds);
                rowsTotal = int.Parse(parameters[0].Value.ToString());
                return ds;
            }
            catch (Exception error)
            {
                throw error;
            }
            finally
            {
                Conn().Close();
            }
        }
    }

-------------------------------------------------------------------------------------------------------------------

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Data.SqlClient;//
using System.Collections;//

/// <summary>
/// SQLHelper 的摘要说明
/// </summary>
public class SQLHelper
{
public SQLHelper()
{
//
// TODO: 在此处添加构造函数逻辑
//
}

private static SqlCommand command = new SqlCommand();//
private static SqlConnection conn = new SqlConnection(ConfigurationSettings.AppSettings["ConnectionString"]);

static SQLHelper()
{
command.Connection = conn;
}
/// <summary>
/// 打开数据库连接
/// </summary>
private static void OpenConnect()
{
if (conn.State == ConnectionState.Open)
{
conn.Close();
}
conn.Open();
}
/// <summary>
/// 关闭数据库连接
/// </summary>
public static void CloseConnect()
{
if (conn.State != ConnectionState.Closed)
{
conn.Close();
}
}
/// <summary>
///
/// </summary>
/// <param name="procName"></param>
/// <param name="prams"></param>
/// <returns></returns>
private static SqlCommand CreateCommand(string procName, SqlParameter[] prams)
{
OpenConnect();//打开DB连接
SqlCommand command = new SqlCommand(procName, conn);
command.CommandType = CommandType.StoredProcedure;
if (prams != null)
{
foreach (SqlParameter parameter in prams)
{
command.Parameters.Add(parameter);
}
}
command.Parameters.Add(new SqlParameter("ReturnValue", SqlDbType.Int, 4, ParameterDirection.ReturnValue, false, 0, 0, string.Empty, DataRowVersion.Default, null));
return command;
}
/// <summary>
/// 执行sql命令语句
/// </summary>
/// <param name="sql">传入要执行的sql语句</param>
public static void ExecuteSql(string sql)
{
OpenConnect();//打开连接

command.CommandType = CommandType.Text;
command.CommandText = sql;
command.ExecuteNonQuery();

CloseConnect();//关闭连接
}


/// <summary>
/// 返回一个DataTable对象
/// </summary>
/// <param name="sql">要执行的SQL命令语句</param>
/// <returns>返回一的DataTable对象</returns>
public static DataTable GetDataTable(string sql)
{
DataSet dataSet = new DataSet();
OpenConnect();//打开DB连接

SqlDataAdapter adapter = new SqlDataAdapter();
adapter.SelectCommand = command;

command.CommandText = sql;
command.CommandType = CommandType.Text;

adapter.Fill(dataSet);

CloseConnect();//关闭DB连接

return dataSet.Tables[0];
}
/// <summary>
/// 返回一的DataTable对象
/// </summary>
/// <param name="sql">要执行的SQL命令语句</param>
/// <param name="pageinfo">第几页</param>
/// <param name="pagesize">每页显示数据项数</param>
/// <param name="name"></param>
/// <returns>返回一的DataTable对象</returns>
public static DataTable GetDataTable(string sql, int pageinfo, int pagesize, string name)
{
DataSet dataSet = new DataSet();
OpenConnect();

SqlDataAdapter adapter = new SqlDataAdapter();
adapter.SelectCommand = command;

command.CommandText = sql;
command.CommandType = CommandType.Text;

adapter.Fill(dataSet, pageinfo, pagesize, name);

CloseConnect();
return dataSet.Tables[0];
}
/// <summary>
/// 返回第一行的第一列的值
/// </summary>
/// <param name="sql">要执行的SQL命令语句</param>
/// <returns>字符串形式返回查询结果第一行的第一列的值</returns>
public static string GetFirstColumnValue(string sql)
{
OpenConnect();

command.CommandType = CommandType.Text;
command.CommandText = sql;

object obj2 = command.ExecuteScalar();

CloseConnect();
if (obj2 == null)
{
return "";
}
return obj2.ToString();
}
/// <summary>
/// 返回一个SqlDataReader对象
/// </summary>
/// <param name="sql">要执行的SQL命令语句</param>
/// <returns></returns>
public static SqlDataReader GetReader(string sql)
{
OpenConnect();

command.CommandType = CommandType.Text;
command.CommandText = sql;

return command.ExecuteReader(CommandBehavior.CloseConnection);//若关闭DataReader对象则关联的Connection对象也将关闭
}
/// <summary>
/// 返回一个bool值判断Reader对象是否存在行
/// </summary>
/// <param name="sql">要执行的SQL命令语句</param>
/// <returns>返回一个bool值判断Reader对象是否存在行</returns>
public static bool IsHasRow(string sql)
{
OpenConnect();

command.CommandType = CommandType.Text;
command.CommandText = sql;

bool flag = command.ExecuteReader().Read();

CloseConnect();

return flag;
}




public static DataSet RunProc(string procName, SqlParameter[] prams)
{
DataSet dataSet = new DataSet();
OpenConnect();
SqlDataAdapter adapter = new SqlDataAdapter();
adapter.SelectCommand = CreateCommand(procName, prams);
adapter.Fill(dataSet);
CloseConnect();
return dataSet;
}

public static void RunProc(string procName, SqlParameter[] prams, out SqlDataReader dataReader)
{
dataReader = CreateCommand(procName, prams).ExecuteReader(CommandBehavior.CloseConnection);
}

public static void RunProcNon(string procName, SqlParameter[] prams)
{
OpenConnect();
CreateCommand(procName, prams).ExecuteNonQuery();
CloseConnect();
}

public static void RunProcNonQuery(string procName, SqlParameter[] prams)
{
CreateCommand(procName, prams).ExecuteNonQuery();
}

public static DataTable RunProcT(string procName, SqlParameter[] prams)
{
DataSet dataSet = new DataSet();
OpenConnect();
SqlDataAdapter adapter = new SqlDataAdapter();
adapter.SelectCommand = CreateCommand(procName, prams);
adapter.Fill(dataSet);
CloseConnect();
return dataSet.Tables[0];
}
//--------------------------------------------------------------------------------------------------------------
public static void ExecuteSqlWithIdentityTrans(ArrayList sqls)
{
string newValue = null;
string str2 = "";
SqlTransaction transaction = null;
try
{
OpenConnect();//打开连接

transaction = conn.BeginTransaction();//开始数据库事务
command.Transaction = transaction;
foreach (string str3 in sqls)
{
str2 = str3;
if (newValue != null)
{
str2 = str3.Replace("IdenStr", newValue);
}
command.CommandType = CommandType.Text;
command.CommandText = str2;
if (str3.IndexOf("Idenity") != -1)
{
newValue = command.ExecuteScalar().ToString();
continue;
}
command.ExecuteNonQuery();
}
transaction.Commit();//提交数据库事务
}
catch (Exception exception)
{
transaction.Rollback();//回滚事务
throw exception;
}
finally
{
CloseConnect();//关闭连接
}
}

public static void ExecuteSqlWithTrans(ArrayList sqls)
{
SqlTransaction transaction = null;
try
{
OpenConnect();

transaction = conn.BeginTransaction();
command.Transaction = transaction;
foreach (string str in sqls)
{
command.CommandType = CommandType.Text;
command.CommandText = str;
command.ExecuteNonQuery();
}
transaction.Commit();
}
catch (Exception exception)
{
transaction.Rollback();
throw exception;
}
finally
{
CloseConnect();
}
}
public static SqlParameter MakeInParam(string ParamName, SqlDbType DbType, int Size, object Value)
{
return MakeParam(ParamName, DbType, Size, ParameterDirection.Input, Value);
}

public static SqlParameter MakeOutParam(string ParamName, SqlDbType DbType, int Size)
{
return MakeParam(ParamName, DbType, Size, ParameterDirection.Output, null);
}

public static SqlParameter MakeParam(string ParamName, SqlDbType DbType, int Size, ParameterDirection Direction, object Value)
{
SqlParameter parameter;
if (Size > 0)
{
parameter = new SqlParameter(ParamName, DbType, Size);
}
else
{
parameter = new SqlParameter(ParamName, DbType);
}
parameter.Direction = Direction;
if ((Direction != ParameterDirection.Output) || (Value != null))
{
parameter.Value = Value;
}
return parameter;
}

public static SqlParameter MakeReturnParam(string ParamName, SqlDbType DbType, int Size)
{
return MakeParam(ParamName, DbType, Size, ParameterDirection.ReturnValue, null);
}

}