c# 数据库 连接池 存储过程

下面的代码来自于网络，只是把连接池设置和存储过程加在一起了

public class DbConn

    {
        private const int MaxPool = 30; //最大连接数 
        private const int MinPool=5;//最小连接数
        private const bool Asyn_Process=true;//设置异步访问数据库  
        private const bool Mars=true;//在单个连接上得到和管理多个、仅向前引用和只读的结果集(ADO.NET2.0)  
        private const int Conn_Timeout=15;//设置连接等待时间
        private const int Conn_Lifetime=15;//设置连接的生命周期  
        private string ConnString="";//连接字符串 
        private SqlConnection SqlDrConn=null;//连接对象 
 
        public void SetConnString(string server,string dbName,string user,string pwd)  
        {
            ConnString = "Server=" + server + ";"
                + "Database=" + dbName + ";"
                + "User ID=" + user + ";"
                + "Password=" + pwd + ";"
                + "Max Pool Size=" + MaxPool + ";"
                + "Min Pool Size=" + MinPool + ";"
                + "Connect Timeout=" + Conn_Timeout + ";"
                + "Connection Lifetime=" + Conn_Lifetime + ";"
                + "Async=" + Asyn_Process + ";"
                + "Integrated Security=sspi"; //当为 false 时，将在连接中指定用户 ID 和密码。当为 true 时，将使用当前的 Windows 帐户凭据进行身份验证(用户名和密码无效)。
                                              // 可识别的值为 true、false、yes、no 以及与 true 等效的 sspi（强烈推荐）。






            SqlDrConn = new SqlConnection(ConnString);
        }  


        public DataTable GetDataReader(string StrSql)//数据查询  
        {  
            //当连接处于打开状态时关闭,然后再打开,避免有时候数据不能及时更新  
            if(SqlDrConn.State==ConnectionState.Open)  
            {  
                SqlDrConn.Close();  
            }  
            try 
            {  
                SqlDrConn.Open();  
                SqlCommand SqlCmd=new SqlCommand(StrSql,SqlDrConn);
                SqlDataReader SqlDr=SqlCmd.ExecuteReader();  
                if(SqlDr.HasRows)  
                {  
                    DataTable dt=new DataTable();  
                    //读取SqlDataReader里的内容  
                    dt.Load(SqlDr);  
                    //关闭对象和连接  
                    SqlDr.Close();  
                    SqlDrConn.Close();  
                    return dt;  
                }  
                return null;  
            }  
            catch(Exception ex)  
            {  
                System.Windows.Forms.MessageBox.Show(ex.Message);  


                return null;  
            }  
            finally 
            {  
                SqlDrConn.Close(); 
            }  
        }
  
        #region 执行不带参数的存储过程，返回存储过程返回值 
        /// <summary> 
        /// 执行存储过程 
        /// </summary> 
        /// <param name="procName">不带参数的存储过程的名称</param> 
        /// <returns>返回存储过程返回值</returns> 
        public int RunProc(string procName)
        {
            SqlCommand cmd = CreateCommand(procName, null);
            cmd.ExecuteNonQuery();
            this.Close();
            return (int)cmd.Parameters["ReturnValue"].Value;
        }
        #endregion


        #region 执行带参数的存储过程，返回存储过程返回值
        /// <summary> 
        /// 执行存储过程 ，已经带有关闭操作
        /// </summary> 
        /// <param name="procName">带参数存储过程名称</param> 
        /// <param name="prams">存储过程所需参数</param> 
        /// <returns>返回存储过程返回值</returns> 
        public int RunProc(string procName, SqlParameter[] prams)
        {
            SqlCommand cmd = CreateCommand(procName, prams);
            cmd.ExecuteNonQuery();
            this.Close();
            return (int)cmd.Parameters["ReturnValue"].Value;
        }
        #endregion


        #region 执行不带参数的存储过程，通过输出参数返回SqlDataReader对象
        /// <summary> 
        /// 执行存储过程 ，不带有关闭操作，使用完后，请注意关闭连接，避免资源浪费
        /// </summary> 
        /// <param name="procName">不带参数的存储过程的名称</param> 
        /// <param name="dataReader">通过输出参数返回SqlDataReader对象</param> 
        public void RunProc(string procName, out SqlDataReader dataReader)
        {
            SqlCommand cmd = CreateCommand(procName, null);
            dataReader = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
        }
        #endregion


        #region 执行带参数的存储过程，通过输出参数返回SqlDataReader对象
        /// <summary> 
        /// 执行存储过程 ，不带有关闭操作，使用完后，请注意关闭连接，避免资源浪费
        /// </summary> 
        /// <param name="procName">带参数的存储过程的名称</param> 
        /// <param name="prams">存储过程所需参数</param> 
        /// <param name="dataReader">通过输出参数返回SqlDataReader对象</param> 
        public void RunProc(string procName, SqlParameter[] prams, out SqlDataReader dataReader)
        {
            SqlCommand cmd = CreateCommand(procName, prams);
            dataReader = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
        }
        #endregion


        #region 创建SqlCommand对象
        /// <summary> 
        /// 创建一个SqlCommand对象以此来执行存储过程 ，不带有关闭操作，使用完后，请注意关闭连接，避免资源浪费
        /// </summary> 
        /// <param name="procName">存储过程的名称</param> 
        /// <param name="prams">存储过程所需参数</param> 
        /// <returns>返回SqlCommand对象</returns> 
        private SqlCommand CreateCommand(string procName, SqlParameter[] prams)
        {
            // 确认打开连接 
            Open();
            SqlCommand cmd = new SqlCommand(procName, SqlDrConn);
            cmd.CommandType = CommandType.StoredProcedure;


            // 依次把参数传入存储过程 
            if (prams != null)
            {
                foreach (SqlParameter parameter in prams)
                    cmd.Parameters.Add(parameter);
            }


            // 加入返回参数 
            cmd.Parameters.Add(
            new SqlParameter("ReturnValue", SqlDbType.Int, 4,
            ParameterDirection.ReturnValue, false, 0, 0,
            string.Empty, DataRowVersion.Default, null));


            return cmd;
        }
        #endregion


        #region 打开数据库连接
        /// <summary> 
        /// 打开数据库连接. 
        /// </summary> 
        private void Open()
        {
            // 打开数据库连接 
            if (SqlDrConn == null)
            {
                SqlDrConn = new SqlConnection(ConnString);  
            }
            else
            {
                //当连接处于打开状态时关闭,然后再打开,避免有时候数据不能及时更新  
                if (SqlDrConn.State == ConnectionState.Open)
                {
                    SqlDrConn.Close();
                }  
            }


            SqlDrConn.Open();


        }
        #endregion


        #region 关闭数据库连接
        /// <summary> 
        /// 关闭数据库连接 
        /// </summary> 
        public void Close()
        {
            if (SqlDrConn != null)
                SqlDrConn.Close();
        }
        #endregion


        #region 释放资源
        /// <summary> 
        /// 释放资源 
        /// </summary> 
        public void Dispose()
        {
            // 确认连接是否已经关闭 
            if (SqlDrConn != null)
            {
                SqlDrConn.Dispose();
                SqlDrConn = null;
            }
        }
        #endregion


        #region 传入输入参数
        /// <summary> 
        /// 传入输入参数 
        /// </summary> 
        /// <param name="ParamName">存储过程参数名称</param> 
        /// <param name="DbType">参数类型</param> 
        /// <param name="Size">参数大小</param> 
        /// <param name="Value">参数值</param> 
        /// <returns>新的 parameter 对象</returns> 
        public SqlParameter MakeInParam(string ParamName, SqlDbType DbType, int Size, object Value)
        {
            return MakeParam(ParamName, DbType, Size, ParameterDirection.Input, Value);
        }
        #endregion


        #region 传入输出参数
        /// <summary> 
        /// 传入输出参数 
        /// </summary> 
        /// <param name="ParamName">存储过程参数名称</param> 
        /// <param name="DbType">参数类型</param> 
        /// <param name="Size">参数大小</param> 
        /// <returns>新的 parameter 对象</returns> 
        public SqlParameter MakeOutParam(string ParamName, SqlDbType DbType, int Size)
        {
            return MakeParam(ParamName, DbType, Size, ParameterDirection.Output, null);
        }
        #endregion


        #region 传入返回值参数
        /// <summary> 
        /// 传入返回值参数 
        /// </summary> 
        /// <param name="ParamName">存储过程参数名称</param> 
        /// <param name="DbType">参数类型</param> 
        /// <param name="Size">参数大小</param> 
        /// <returns>新的 parameter 对象</returns> 
        public SqlParameter MakeReturnParam(string ParamName, SqlDbType DbType, int Size)
        {
            return MakeParam(ParamName, DbType, Size, ParameterDirection.ReturnValue, null);
        }
        #endregion


        #region 生成存储过程参数
        /// <summary> 
        /// 生成存储过程参数 
        /// </summary> 
        /// <param name="ParamName">存储过程参数名称</param> 
        /// <param name="DbType">参数类型</param> 
        /// <param name="Size">参数大小</param> 
        /// <param name="Direction">参数方向</param> 
        /// <param name="Value">参数值</param> 
        /// <returns>新的 parameter 对象</returns> 
        public SqlParameter MakeParam(string ParamName, SqlDbType DbType, Int32 Size, ParameterDirection Direction, object Value)
        {
            SqlParameter param;


            if (Size > 0)
                param = new SqlParameter(ParamName, DbType, Size);
            else
                param = new SqlParameter(ParamName, DbType);


            param.Direction = Direction;
            if (!(Direction == ParameterDirection.Output && Value == null))
                param.Value = Value;


            return param;
        }
        #endregion


        #region 将DataReader 转为 DataTable
        /// <summary> 
        /// 将DataReader 转为 DataTable 
        /// </summary> 
        /// <param name="DataReader">DataReader</param> 
        public static DataTable ConvertDataReaderToDataTable(SqlDataReader reader)
        {
            try
            {


                DataTable objDataTable = new DataTable();
                int intFieldCount = reader.FieldCount;
                for (int intCounter = 0; intCounter < intFieldCount; ++intCounter)
                {
                    objDataTable.Columns.Add(reader.GetName(intCounter), reader.GetFieldType(intCounter));
                }


                objDataTable.BeginLoadData();


                object[] objValues = new object[intFieldCount];
                while (reader.Read())
                {
                    reader.GetValues(objValues);
                    objDataTable.LoadDataRow(objValues, true);
                }
                reader.Close();
                objDataTable.EndLoadData();


                return objDataTable;


            }
            catch (Exception ex)
            {
                throw new Exception("转换DataReader为DataTable出错!", ex);
            }


        }
        #endregion


        #region 数字判定
        /// <summary> 
        /// 数字判定 
        /// </summary> 
        /// <param name="str">字符串参数</param> 
        public static bool IsNumber(String strNumber)
        {
            Regex objNotNumberPattern = new Regex("[^0-9.-]");
            Regex objTwoDotPattern = new Regex("[0-9]*[.][0-9]*[.][0-9]*");
            Regex objTwoMinusPattern = new Regex("[0-9]*[-][0-9]*[-][0-9]*");
            String strValidRealPattern = "^([-]|[.]|[-.]|[0-9])[0-9]*[.]*[0-9]+$";
            String strValidIntegerPattern = "^([-]|[0-9])[0-9]*$";
            Regex objNumberPattern = new Regex("(" + strValidRealPattern + ")|(" + strValidIntegerPattern + ")");


            return !objNotNumberPattern.IsMatch(strNumber) &&
            !objTwoDotPattern.IsMatch(strNumber) &&
            !objTwoMinusPattern.IsMatch(strNumber) &&
            objNumberPattern.IsMatch(strNumber);
        }
        #endregion

    }  

用SqlDataReader获取DataTable

public DataTable Convertdrtodt(SqlDataReader dr)
    {
        DataTable dataTable = new DataTable();//建一个新的实例

        
        for(int i=0; i<dr.FieldCount;i++)
        {
            DataColumn mydc = new DataColumn();//关键的一步
            mydc.DataType = dr.GetFieldType(i);
            mydc.ColumnName = dr.GetName(i);

            dataTable.Columns.Add(mydc);//关键的第二步
        }

        while (dr.Read())
        {
            DataRow mydr = dataTable.NewRow();//关键的第三步
            for (int i = 0; i < dr.FieldCount; i++)
            {
                mydr[i] = dr[i].ToString();
            }

            dataTable.Rows.Add(mydr);//关键的第四步
            mydr = null;
        }

        dr.Close();
        return (dataTable);//别忘了要返回datatable，否则出错

    }