对数据库访问基类进行封装

using  System;
using  System.Collections;
using  System.Data;
using  System.Data.SqlClient;
using  System.Configuration;
namespace  ZXY.Modules.DataAccess 
{
     ///   <summary>
     ///  数据访问基础类(基于SQLServer)
     ///  张信元
     ///  2007-03-30
     public   class  DataProvider
    {
         #region  变量
        
         private   string  connectionString  =   string .Empty;

         #endregion
        
         #region  方法
        
         #region  构造函数
         ///   <summary>
         ///  创建数据提供对象
         ///   </summary>
         ///   <param name="dbConnectionStrParmName"> 数据库连接串在config中的参数名称 </param>
         public  DataProvider( string  dbConnectionStrParmName)
        {
            connectionString  =  ConfigurationSettings.AppSettings[dbConnectionStrParmName];
        }
        
//          // / <summary>
//          // / 创建数据提供对象
//          // / </summary>
//          // / <param name="server">服务器名称</param>
//          // / <param name="dataBase">数据库名称</param>
//          // / <param name="uid">用户名</param>
//          // / <param name="pwd">密码</param>
//         public DataProvider(string server,string dataBase,string uid,string pwd)
//         {
//             connectionString = "server="+server+";DataBase="+dataBase+";uid="+uid+";pwd="+pwd+";";
//         }
//         
         #endregion
        
         #region  私有方法
        
         ///   <summary>
         ///  设定SQL语句
         ///   </summary>
         ///   <param name="storedProcName"> 存储过程名 </param>
         ///   <param name="parmsValue"> 参数值 </param>
         ///   <returns> sql语句 </returns>
         private   string  SetParmsValues( string  storedProcName, params   object [] parmsValue)
        {
             string  strSql  =   string .Empty;
             for ( int  i = 0 ;i < parmsValue.Length;i ++ )
            {
                strSql  =   string .Format(storedProcName  +   "   '{0}' " , parmsValue[i]);
                 if (parmsValue.Length > 1 )
                {
                     if (i != parmsValue.Length - 1 )
                    {
                        strSql  =   string .Format(storedProcName  +   "   '{0}', " , parmsValue[i]);
                    }
                }
                storedProcName  =  strSql;
            }
             return  strSql;
        }
         #region  TEMP
         /*
        /// <summary>
        /// ArrayList类型转换成数据参数类型
        /// </summary>
        /// <param name="parmsValue"></param>
        /// <returns></returns>
        private IDataParameter[] SetSqlParameter(string[] parmsName,ArrayList parmsValue)
        {
            int count = parmsName.Length;
            SqlParameter[] parameters = new SqlParameter[count];
            for(int i=0;i<count;i++)
            {
                parameters[i] =  new SqlParameter(parmsName[i],parmsValue[i].GetType());
                parameters[i].Value = parmsValue[i];
            }
            return parameters;
        }
         */
         #endregion
        
         ///   <summary>
         ///  数据参数赋值
         ///   </summary>
         ///   <param name="parmsName"> 参数名称 </param>
         ///   <param name="parmsValue"> 参数值 </param>
         ///   <returns></returns>
         private  SqlParameter[] SetSqlParameter( string [] parmsName,ArrayList parmsValue)
        {
             int  count  =  parmsName.Length;
            SqlParameter[] parameters  =   new  SqlParameter[count];
             for ( int  i = 0 ;i < count;i ++ )
            {
                parameters[i]  =   new  SqlParameter(parmsName[i],parmsValue[i].GetType());
                parameters[i].Value  =  parmsValue[i];
            }
             return  parameters;
        }
        
         ///   <summary>
         ///  
         ///   </summary>
         ///   <param name="cmd"></param>
         ///   <param name="conn"></param>
         ///   <param name="trans"></param>
         ///   <param name="cmdText"></param>
         ///   <param name="cmdParms"></param>
         private    void  PrepareCommand(SqlCommand cmd,SqlConnection conn,SqlTransaction trans,  string  cmdText, SqlParameter[] cmdParms) 
        {
             if  (conn.State  !=  ConnectionState.Open)
                conn.Open();
            cmd.Connection  =  conn;
            cmd.CommandText  =  cmdText;
             if  (trans  !=   null )
                cmd.Transaction  =  trans;
            cmd.CommandType  =  CommandType.Text; // cmdType;
             if  (cmdParms  !=   null ) 
            {
                 foreach  (SqlParameter parm  in  cmdParms)
                    cmd.Parameters.Add(parm);
            }
        }
        
         ///   <summary>
         ///  构建 SqlCommand 对象(用来返回一个结果集，而不是一个整数值)
         ///   </summary>
         ///   <param name="connection"> 数据库连接 </param>
         ///   <param name="storedProcName"> 存储过程名 </param>
         ///   <param name="parameters"> 存储过程参数 </param>
         ///   <returns> SqlCommand </returns>
         private   SqlCommand BuildQueryCommand(SqlConnection connection, string  storedProcName, IDataParameter[] parameters)
        {            
            SqlCommand command  =   new  SqlCommand( storedProcName, connection );
            command.CommandType  =  CommandType.StoredProcedure;
             foreach  (SqlParameter parameter  in  parameters)
            {
                command.Parameters.Add( parameter );
            }
             return  command;            
        }
        
         ///   <summary>
         ///  创建 SqlCommand 对象实例(用来返回一个整数值)    
         ///   </summary>
         ///   <param name="storedProcName"> 存储过程名 </param>
         ///   <param name="parameters"> 存储过程参数 </param>
         ///   <returns> SqlCommand 对象实例 </returns>
         private   SqlCommand BuildIntCommand(SqlConnection connection, string  storedProcName, IDataParameter[] parameters)
        {
            SqlCommand command  =  BuildQueryCommand(connection,storedProcName, parameters );
            command.Parameters.Add(  new  SqlParameter (  " ReturnValue " ,
                SqlDbType.Int, 4 ,ParameterDirection.ReturnValue,
                 false , 0 , 0 , string .Empty,DataRowVersion.Default, null  ));
             return  command;
        }
         #endregion

         #region  公用方法
        
         #region  GetMaxID
         ///   <summary>
         ///  获取表某个字段的最大值
         ///   </summary>
         ///   <param name="FieldName"> 字段名称 </param>
         ///   <param name="TableName"> 表名称 </param>
         ///   <returns></returns>
         public   int  GetMaxID( string  FieldName, string  TableName)
        {
             string  strsql  =   " select max( "   +  FieldName  +   " )+1 from  "   +  TableName;
             object  obj  =  ExecuteScalar(strsql);
             if  (obj  ==   null )
            {
                 return   1 ;
            }
             else
            {
                 return   int .Parse(obj.ToString());
            }
        }
         #endregion  
        
         #region  Exists
        
         ///   <summary>
         ///  检测一个记录是否存在(SQL语句方式)
         ///   </summary>
         ///   <param name="strSql"></param>
         ///   <returns></returns>
         public   bool  Exists( string  strSql)
        {
             object  obj  =  ExecuteScalar(strSql);
             int  cmdresult;
             if  ((Object.Equals(obj,  null ))  ||  (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult  =   0 ;
            }
             else
            {
                cmdresult  =   int .Parse(obj.ToString());
            }
             if  (cmdresult  ==   0 )
            {
                 return   false ;
            }
             else
            {
                 return   true ;
            }
        }
        
         ///   <summary>
         ///  检测一个记录是否存在(SQL语句方式)
         ///   </summary>
         ///   <param name="strSql"></param>
         ///   <returns></returns>
         private   bool  Exists( string  strSql, string [] parmsName,ArrayList parmsValue)
        {
            SqlParameter[] cmdParms  =  SetSqlParameter(parmsName, parmsValue);
             return  Exists(strSql,cmdParms);
        }
        
         ///   <summary>
         ///  检测一个记录是否存在(SQL语句方式)
         ///   </summary>
         ///   <param name="strSql"></param>
         ///   <param name="cmdParms"></param>
         ///   <returns></returns>
         private   bool  Exists( string  strSql,  params  SqlParameter[] cmdParms)
        {
             object  obj  =  ExecuteScalar(strSql, cmdParms);
             int  cmdresult;
             if  ((Object.Equals(obj,  null ))  ||  (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult  =   0 ;
            }
             else
            {
                cmdresult  =   int .Parse(obj.ToString());
            }
             if  (cmdresult  ==   0 )
            {
                 return   false ;
            }
             else
            {
                 return   true ;
            }
        }
         #endregion  
        
         #region  ExecuteNonQuery
        
         ///   <summary>
         ///  执行带参数存储过程，返回影响的记录数
         ///   </summary>
         ///   <param name="storedProcName"> 存储过程 </param>
         ///   <returns> 影响的记录数 </returns>
         public   int  ExecuteNonQuery( string  storedProcName, params   object [] paramsValue)
        {
            storedProcName  =  SetParmsValues(storedProcName, paramsValue);
             using  (SqlConnection connection  =   new  SqlConnection(connectionString))
            {                
                 using  (SqlCommand cmd  =   new  SqlCommand(storedProcName,connection))
                {
                     try
                    {        
                        connection.Open();
                         int  rows = cmd.ExecuteNonQuery();
                         return  rows;
                    }
                     catch (SqlException E)
                    {                    
                        connection.Close();
                         throw   new  Exception(E.Message);
                    }
                }                
            }
        }
        
         ///   <summary>
         ///  执行SQL语句或无参数存储过程，返回影响的记录数
         ///   </summary>
         ///   <param name="SQLString"> SQL语句 </param>
         ///   <returns> 影响的记录数 </returns>
         public   int  ExecuteNonQuery( string  SQLString)
        {
             using  (SqlConnection connection  =   new  SqlConnection(connectionString))
            {                
                 using  (SqlCommand cmd  =   new  SqlCommand(SQLString,connection))
                {
                     try
                    {        
                        connection.Open();
                         int  rows = cmd.ExecuteNonQuery();
                         return  rows;
                    }
                     catch (SqlException E)
                    {                    
                        connection.Close();
                         throw   new  Exception(E.Message);
                    }
                }                
            }
        }
        
         ///   <summary>
         ///  执行带一个存储过程参数的的SQL语句。
         ///   </summary>
         ///   <param name="SQLString"> SQL语句 </param>
         ///   <param name="content"> 参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加 </param>
         ///   <returns> 影响的记录数 </returns>
         private   int  ExecuteNonQuery( string  SQLString, string  content)
        {                
             using  (SqlConnection connection  =   new  SqlConnection(connectionString))
            {
                SqlCommand cmd  =   new  SqlCommand(SQLString,connection);        
                SqlParameter  myParameter  =   new  SqlParameter(  " @content " , SqlDbType.NText);
                myParameter.Value  =  content ;
                cmd.Parameters.Add(myParameter);
                 try
                {
                    connection.Open();
                     int  rows = cmd.ExecuteNonQuery();
                     return  rows;
                }
                 catch (SqlException E)
                {                
                     throw   new  Exception(E.Message);
                }
                 finally
                {
                    cmd.Dispose();
                    connection.Close();
                }    
            }
        }    
        
         ///   <summary>
         ///  向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
         ///   </summary>
         ///   <param name="strSQL"> SQL语句 </param>
         ///   <param name="fs"> 图像字节,数据库的字段类型为image的情况 </param>
         ///   <returns> 影响的记录数 </returns>
         private   int  ExecuteNonQuery( string  strSQL, byte [] fs)
        {        
             using  (SqlConnection connection  =   new  SqlConnection(connectionString))
            {
                SqlCommand cmd  =   new  SqlCommand(strSQL,connection);    
                SqlParameter  myParameter  =   new  SqlParameter (  " @fs " , SqlDbType.Image);
                myParameter.Value  =  fs ;
                cmd.Parameters.Add(myParameter);
                 try
                {
                    connection.Open();
                     int  rows = cmd.ExecuteNonQuery();
                     return  rows;
                }
                 catch (SqlException E)
                {                
                     throw   new  Exception(E.Message);
                }
                 finally
                {
                    cmd.Dispose();
                    connection.Close();
                }                
            }
        }
        
         ///   <summary>
         ///  执行SQL语句，返回影响的记录数
         ///   </summary>
         ///   <param name="SQLString"> SQL语句 </param>
         ///   <returns> 影响的记录数 </returns>
         private   int  ExecuteNonQuery( string  SQLString, string [] parmsName,ArrayList parmsValue)
        {
            SqlParameter[] cmdParms  =  SetSqlParameter(parmsName, parmsValue);
             return  ExecuteNonQuery(SQLString, cmdParms);
        }
         ///   <summary>
         ///  执行SQL语句，返回影响的记录数
         ///   </summary>
         ///   <param name="SQLString"> SQL语句 </param>
         ///   <returns> 影响的记录数 </returns>
         private   int  ExecuteNonQuery( string  SQLString, params  SqlParameter[] cmdParms)
        {
             using  (SqlConnection connection  =   new  SqlConnection(connectionString))
            {                
                 using  (SqlCommand cmd  =   new  SqlCommand())
                {
                     try
                    {        
                        PrepareCommand(cmd, connection,  null ,SQLString, cmdParms);
                         int  rows = cmd.ExecuteNonQuery();
                        cmd.Parameters.Clear();
                         return  rows;
                    }
                     catch (SqlException E)
                    {                
                         throw   new  Exception(E.Message);
                    }
                }                
            }
        }

         ///   <summary>
         ///  执行存储过程，返回影响的行数        
         ///   </summary>
         ///   <param name="storedProcName"> 存储过程名 </param>
         ///   <param name="rowsAffected"> 影响的行数 </param>
         ///   <returns></returns>
         private   int  ExecuteNonQuery( string  storedProcName, string [] parmsName,ArrayList parmsValue, out   int  rowsAffected)
        {
            IDataParameter[] parameters  =  SetSqlParameter(parmsName,parmsValue);
             int  returnValue  =  ExecuteNonQuery(storedProcName, parameters, out  rowsAffected);
             return  returnValue;
        }
         ///   <summary>
         ///  执行存储过程，返回影响的行数        
         ///   </summary>
         ///   <param name="storedProcName"> 存储过程名 </param>
         ///   <param name="parameters"> 存储过程参数 </param>
         ///   <param name="rowsAffected"> 影响的行数 </param>
         ///   <returns></returns>
         private   int  ExecuteNonQuery( string  storedProcName, IDataParameter[] parameters,  out   int  rowsAffected)
        {
             using  (SqlConnection connection  =   new  SqlConnection(connectionString))
            {
                 int  result;
                connection.Open();
                SqlCommand command  =  BuildIntCommand(connection,storedProcName, parameters );
                rowsAffected  =  command.ExecuteNonQuery();
                result  =  ( int )command.Parameters[ " ReturnValue " ].Value;
                 return  result;
            }
        }
        
         #endregion
        
         #region  ExecuteScalar
        
         ///   <summary>
         ///  执行一条计算查询结果语句，返回查询结果（object）。
         ///   </summary>
         ///   <param name="storedProcName"> 存储过程 </param>
         ///   <returns> 查询结果（object） </returns>
         public   object  ExecuteScalar( string  storedProcName, params   object [] parmsValue)
        {
            storedProcName  =  SetParmsValues(storedProcName, parmsValue);
             return  ExecuteScalar(storedProcName);
        }
        
         ///   <summary>
         ///  执行一条计算查询结果语句，返回查询结果（object）。
         ///   </summary>
         ///   <param name="SQLString"> 计算查询结果语句 </param>
         ///   <returns> 查询结果（object） </returns>
         public   object  ExecuteScalar( string  SQLString)
        {
             using  (SqlConnection connection  =   new  SqlConnection(connectionString))
            {
                 using (SqlCommand cmd  =   new  SqlCommand(SQLString,connection))
                {
                     try
                    {
                        connection.Open();
                         object  obj  =  cmd.ExecuteScalar();
                         if ((Object.Equals(obj, null )) || (Object.Equals(obj,System.DBNull.Value)))
                        {                    
                             return   null ;
                        }
                         else
                        {
                             return  obj;
                        }                
                    }
                     catch (SqlException e)
                    {                        
                        connection.Close();
                         throw   new  Exception(e.Message);
                    }    
                }
            }
        }

         ///   <summary>
         ///  执行一条计算查询结果语句，返回查询结果（object）。
         ///   </summary>
         ///   <param name="storedProcName"> 存储过程 </param>
         ///   <returns> 查询结果（object） </returns>
         public   object  ExecuteScalar( string  storedProcName, string [] parmsName,ArrayList parmsValue)
        {
            SqlParameter[] cmdParms  =  SetSqlParameter(parmsName, parmsValue);
             return  ExecuteScalar(storedProcName, cmdParms);
        }
        
         ///   <summary>
         ///  执行一条计算查询结果语句，返回查询结果（object）。
         ///   </summary>
         ///   <param name="SQLString"> 计算查询结果语句 </param>
         ///   <param name="cmdParms"> Sql参数 </param>
         ///   <returns> 查询结果（object） </returns>
         private   object  ExecuteScalar( string  SQLString, params  SqlParameter[] cmdParms)
        {
             using  (SqlConnection connection  =   new  SqlConnection(connectionString))
            {
                 using  (SqlCommand cmd  =   new  SqlCommand())
                {
                     try
                    {
                        PrepareCommand(cmd, connection,  null ,SQLString, cmdParms);
                         object  obj  =  cmd.ExecuteScalar();
                        cmd.Parameters.Clear();
                         if ((Object.Equals(obj, null )) || (Object.Equals(obj,System.DBNull.Value)))
                        {                    
                             return   null ;
                        }
                         else
                        {
                             return  obj;
                        }                
                    }
                     catch (SqlException e)
                    {                
                         throw   new  Exception(e.Message);
                    }                    
                }
            }
        }    
         #endregion  
        
         #region  ExecuteReader
         ///   <summary>
         ///  执行查询语句，返回SqlDataReader
         ///   </summary>
         ///   <param name="strSQL"> 查询语句 </param>
         ///   <returns> SqlDataReader </returns>
         public   SqlDataReader ExecuteReader( string  strSQL)
        {
            SqlConnection connection  =   new  SqlConnection(connectionString);            
            SqlCommand cmd  =   new  SqlCommand(strSQL,connection);                
             try
            {
                connection.Open();    
                SqlDataReader myReader  =  cmd.ExecuteReader();
                 return  myReader;
            }
             catch (SqlException e)
            {                                
                 throw   new  Exception(e.Message);
            }            
        }        
        
         ///   <summary>
         ///  执行查询语句，返回SqlDataReader
         ///   </summary>
         ///   <param name="SQLString"> 查询语句 </param>
         ///   <returns> SqlDataReader </returns>
         private  SqlDataReader ExecuteReader( string  SQLString, params  SqlParameter[] cmdParms)
        {        
            SqlConnection connection  =   new  SqlConnection(connectionString);
            SqlCommand cmd  =   new  SqlCommand();                
             try
            {
                PrepareCommand(cmd, connection,  null ,SQLString, cmdParms);
                SqlDataReader myReader  =  cmd.ExecuteReader();
                cmd.Parameters.Clear();
                 return  myReader;
            }
             catch (SqlException e)
            {                                
                 throw   new  Exception(e.Message);
            }                
        }
        
         ///   <summary>
         ///  执行存储过程
         ///   </summary>
         ///   <param name="storedProcName"> 存储过程名 </param>
         ///   <returns> SqlDataReader </returns>
         public   SqlDataReader ExecuteReader( string  storedProcName, params   object [] parmsValue)
        {
             string  sqlWithParmsValue  =  SetParmsValues(storedProcName, parmsValue);
             return  ExecuteReader(sqlWithParmsValue);
        }
        
         ///   <summary>
         ///  执行存储过程
         ///   </summary>
         ///   <param name="storedProcName"> 存储过程名 </param>
         ///   <returns> SqlDataReader </returns>
         public   SqlDataReader ExecuteReader( string  storedProcName, string [] parmsName,ArrayList parmsValue)
        {
            IDataParameter[] parameters  =  SetSqlParameter(parmsName, parmsValue);
             return  ExecuteReader(storedProcName, parameters);
        }
         ///   <summary>
         ///  执行存储过程
         ///   </summary>
         ///   <param name="storedProcName"> 存储过程名 </param>
         ///   <param name="parameters"> 存储过程参数 </param>
         ///   <returns> SqlDataReader </returns>
         private  SqlDataReader ExecuteReader( string  storedProcName, IDataParameter[] parameters )
        {
            SqlConnection connection  =   new  SqlConnection(connectionString);
            SqlDataReader returnReader;
            connection.Open();
            SqlCommand command  =  BuildQueryCommand( connection,storedProcName, parameters );
            command.CommandType  =  CommandType.StoredProcedure;
            returnReader  =  command.ExecuteReader();                
             return  returnReader;            
        }
        
         #endregion  
        
         #region  ExecuteDataRow
         ///   <summary>
         ///  执行查询语句，返回DataRow
         ///   </summary>
         ///   <param name="SQLString"> 查询语句 </param>
         ///   <returns> DataRow </returns>
         public  DataRow ExecuteDataRow( string  SQLString)
        {
            DataRow dr  =  ExecuteDataSet(SQLString).Tables[ 0 ].Rows[ 0 ];    
             return  dr;
        }
        
         #endregion
        
         #region  ExecuteDataSet
         ///   <summary>
         ///  执行查询语句，返回DataSet
         ///   </summary>
         ///   <param name="SQLString"> 查询语句 </param>
         ///   <returns> DataSet </returns>
         public   DataSet ExecuteDataSet( string  SQLString)
        {
             using  (SqlConnection connection  =   new  SqlConnection(connectionString))
            {
                DataSet ds  =   new  DataSet();
                 try
                {
                    connection.Open();
                    SqlDataAdapter command  =   new  SqlDataAdapter(SQLString,connection);                
                    command.Fill(ds, " ds " );
                }
                 catch (SqlException ex)
                {                
                     throw   new  Exception(ex.Message);
                }            
                 return  ds;
            }            
        }
        
         ///   <summary>
         ///  执行查询语句，返回DataSet
         ///   </summary>
         ///   <param name="SQLString"> 查询语句 </param>
         ///   <returns> DataSet </returns>
//         private  DataSet ExecuteDataSet(string SQLString,string[] parmsName,ArrayList parmsValue)
//         {
//             SqlParameter[] cmdParms = SetSqlParameter(parmsName, parmsValue);
//             return ExecuteDataSet(SQLString, cmdParms);
//         }
        
         ///   <summary>
         ///  执行存储过程，返回DataSet
         ///   </summary>
         ///   <param name="storedProcName"> 存储过程名 </param>
         ///   <param name="parmsValue"> 参数值 </param>
         ///   <returns> DataSet </returns>
         public   DataSet ExecuteDataSet( string  storedProcName, params   object [] parmsValue)
        {
             string  sqlWithParmsValue  =  SetParmsValues(storedProcName, parmsValue);
             return  ExecuteDataSet(sqlWithParmsValue);
        }
        
         ///   <summary>
         ///  执行查询语句，返回DataSet
         ///   </summary>
         ///   <param name="SQLString"> 查询语句 </param>
         ///   <returns> DataSet </returns>
         private  DataSet ExecuteDataSet( string  SQLString, params  SqlParameter[] cmdParms)
        {
             using  (SqlConnection connection  =   new  SqlConnection(connectionString))
            {
                SqlCommand cmd  =   new  SqlCommand();
                PrepareCommand(cmd, connection,  null ,SQLString, cmdParms);
                 using ( SqlDataAdapter da  =   new  SqlDataAdapter(cmd) )
                {
                    DataSet ds  =   new  DataSet();    
                     try
                    {                                                
                        da.Fill(ds, " ds " );
                        cmd.Parameters.Clear();
                    }
                     catch (SqlException ex)
                    {                
                         throw   new  Exception(ex.Message);
                    }            
                     return  ds;
                }                
            }            
        }
        
         ///   <summary>
         ///  执行存储过程
         ///   </summary>
         ///   <param name="storedProcName"> 存储过程名 </param>
         ///   <returns> DataSet </returns>
         public   DataSet ExecuteDataSet( string  storedProcName, string [] parmsName,ArrayList parmsValue)
        {
            IDataParameter[] parameters  =  SetSqlParameter(parmsName, parmsValue);
             return  ExecuteDataSet(storedProcName, parameters, " ZXYTable " );
        }
        
         ///   <summary>
         ///  执行存储过程
         ///   </summary>
         ///   <param name="storedProcName"> 存储过程名 </param>
         ///   <param name="tableName"> DataSet结果中的表名 </param>
         ///   <returns> DataSet </returns>
         public   DataSet ExecuteDataSet( string  storedProcName, string [] parmsName,ArrayList parmsValue,  string  tableName)
        {
            IDataParameter[] parameters  =  SetSqlParameter(parmsName, parmsValue);
             return  ExecuteDataSet(storedProcName, parameters, tableName);
        }
        
         ///   <summary>
         ///  执行存储过程
         ///   </summary>
         ///   <param name="storedProcName"> 存储过程名 </param>
         ///   <param name="parameters"> 存储过程参数 </param>
         ///   <param name="tableName"> DataSet结果中的表名 </param>
         ///   <returns> DataSet </returns>
         private  DataSet ExecuteDataSet( string  storedProcName, IDataParameter[] parameters,  string  tableName)
        {
             using  (SqlConnection connection  =   new  SqlConnection(connectionString))
            {
                DataSet dataSet  =   new  DataSet();
                connection.Open();
                SqlDataAdapter sqlDA  =   new  SqlDataAdapter();
                sqlDA.SelectCommand  =  BuildQueryCommand(connection, storedProcName, parameters );
                sqlDA.Fill( dataSet, tableName );
                connection.Close();
                 return  dataSet;
            }
        }
        
         #endregion
        
         #region  ExecuteSqlTran
         ///   <summary>
         ///  执行多条SQL语句，实现数据库事务。
         ///   </summary>
         ///   <param name="SQLStringList"> 多条SQL语句 </param>         
         public   void  ExecuteSqlTran(ArrayList SQLStringList)
        {
             using  (SqlConnection conn  =   new  SqlConnection(connectionString))
            {
                conn.Open();
                SqlCommand cmd  =   new  SqlCommand();
                cmd.Connection = conn;                
                SqlTransaction tx = conn.BeginTransaction();            
                cmd.Transaction = tx;                
                 try
                {           
                     for ( int  n = 0 ;n < SQLStringList.Count;n ++ )
                    {
                         string  strsql = SQLStringList[n].ToString();
                         if  (strsql.Trim().Length > 1 )
                        {
                            cmd.CommandText = strsql;
                            cmd.ExecuteNonQuery();
                        }
                    }                                        
                    tx.Commit();                    
                }
                 catch (SqlException E)
                {        
                    tx.Rollback();
                     throw   new  Exception(E.Message);
                }
            }
        }
        
         ///   <summary>
         ///  执行多条SQL语句，实现数据库事务。
         ///   </summary>
         ///   <param name="SQLStringList"> SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]） </param>
         public   void  ExecuteSqlTran(Hashtable SQLStringList)
        {            
             using  (SqlConnection conn  =   new  SqlConnection(connectionString))
            {
                conn.Open();
                 using  (SqlTransaction trans  =  conn.BeginTransaction()) 
                {
                    SqlCommand cmd  =   new  SqlCommand();
                     try  
                    {
                         // 循环
                         foreach  (DictionaryEntry myDE  in  SQLStringList)
                        {    
                             string      cmdText = myDE.Key.ToString();
                            SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
                            PrepareCommand(cmd,conn,trans,cmdText, cmdParms);
                             int  val  =  cmd.ExecuteNonQuery();
                            cmd.Parameters.Clear();

                            trans.Commit();
                        }                    
                    }
                     catch  
                    {
                        trans.Rollback();
                         throw ;
                    }
                }                
            }
        }
         #endregion  
        
         #endregion
        
         #endregion  

    }
}