数据库操作类SqlServer

using  System;
using  System.ComponentModel;
using  System.Collections;
using  System.Diagnostics;
using  System.Data;
using  System.Data.SqlClient;
using  System.Configuration;

namespace  DataBase
... {
    /**//// <summary>
    /// 通用的数据库处理类，通过ado.net与数据库连接
    /// </summary>
    public partial class Database : System.Web.UI.Page
    ...{
        // 连接数据源
        private SqlConnection con;

        /**//// <summary>
        /// 打开数据库连接.
        /// </summary>
        private void Open()
        ...{
            // 打开数据库连接
            if (con == null)
            ...{
                con = new SqlConnection(ConfigurationManager.AppSettings["ConnectionString"].ToString());
            }
            if (con.State == ConnectionState.Closed)
            ...{
                try
                ...{
                    /**////打开数据库连接
                    con.Open();
                }
                catch (Exception ex)
                ...{
                    SystemError.SystemLog(ex.Message);
                }
                finally
                ...{
                    /**////关闭已经打开的数据库连接                
                }
            }
        }

        /**//// <summary>
        /// 关闭数据库连接
        /// </summary>
        public void Close()
        ...{
            /**////判断连接是否已经创建
            if (con != null)
            ...{
                /**////判断连接的状态是否打开
                if (con.State == ConnectionState.Open)
                ...{
                    con.Close();
                }
            }
        }

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

        /**//// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="procName">存储过程的名称</param>
        /// <returns>返回存储过程返回值</returns>
        public int RunProc(string procName)
        ...{
            SqlCommand cmd = CreateCommand(procName, null);
            try
            ...{
                cmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            ...{
                SystemError.SystemLog(ex.Message);
            }
            Close();
            return (int)cmd.Parameters["ReturnValue"].Value;
        }

        /**//// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="procName">存储过程名称</param>
        /// <param name="prams">存储过程所需参数</param>
        /// <returns>返回存储过程返回值</returns>
        public int RunProc(string procName, SqlParameter[] prams)
        ...{
            Open();
            SqlCommand cmd = CreateCommand(procName, prams);
            try
            ...{
                cmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            ...{
                SystemError.SystemLog(ex.Message);
            }
            Close();
            return (int)cmd.Parameters["ReturnValue"].Value;
        }

        /**//// <summary>
        /// 
        /// </summary>
        /// <param name="procName"></param>
        /// <param name="prams"></param>
        /// <returns></returns>
        public void RunProcVoid(string procName, SqlParameter[] prams)
        ...{
            Open();
            SqlCommand cmd = CreateCommand(procName, prams);
            try
            ...{
                cmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            ...{
                SystemError.SystemLog(ex.Message);
            }
            Close();
            /**////return (int)cmd.Parameters["ReturnValue"].Value;
        }
        /**//// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="procName">存储过程的名称</param>
        /// <param name="dataReader">返回存储过程返回值</param>
        public void RunProc(string procName, out SqlDataReader dataReader)
        ...{
            Open();
            SqlCommand cmd = CreateCommand(procName, null);
            dataReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
        }

        /**//// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="procName">存储过程的名称</param>
        /// <param name="prams">存储过程所需参数</param>
        /// <param name="dataReader">存储过程所需参数</param>
        public void RunProc(string procName, SqlParameter[] prams, out SqlDataReader dataReader)
        ...{
            Open();
            SqlCommand cmd = CreateCommand(procName, prams);
            dataReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
        }

        /**//// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="procName">存储过程的名称</param>
        /// <param name="dataadapter">存储过程的参数</param>
        public void RunProc(string procName, out SqlDataAdapter dataadapter)
        ...{
            Open();
            dataadapter = new SqlDataAdapter(procName, con);
        }
        /**//// <summary>
        /// 执行存储过程返回SqlDataAdapter类型
        /// </summary>
        /// <param name="procName">存储过程的名称</param>
        /// <param name="prams">存储过程所需参数</param>
        /// <param name="dataadapter">输出类型</param>
        public void RunProc(string procName, SqlParameter[] prams, out SqlDataAdapter dataadapter)
        ...{
            Open();
            SqlCommand cmd = CreateCommand(procName, prams);
            dataadapter = new SqlDataAdapter(cmd);
            dataadapter.SelectCommand.CommandType = CommandType.StoredProcedure;
        }
        /**//// <summary>
        /// 执行存储过程返回DataTable类型
        /// </summary>
        /// <param name="procName"></param>
        /// <param name="prams">存储过程参数</param>
        /// <param name="bindtable">返回DataTable类型</param>
        public void RunProc(string procName, SqlParameter[] prams, out DataTable bindtable)
        ...{
            Open();
            SqlCommand cmd = CreateCommand(procName, prams);
            SqlDataAdapter dataadapter = new SqlDataAdapter(cmd);
            dataadapter.SelectCommand.CommandType = CommandType.StoredProcedure;
            DataSet DSBind = new DataSet();
            dataadapter.Fill(DSBind);
            bindtable = DSBind.Tables[0];
        }

        public void RunProc(string procName, out DataTable bindtable)
        ...{
            Open();
            SqlCommand cmd = new SqlCommand(procName, con);
            SqlDataAdapter dataadapter = new SqlDataAdapter(cmd);
            dataadapter.SelectCommand.CommandType = CommandType.StoredProcedure;
            DataSet DSBind = new DataSet();
            dataadapter.Fill(DSBind);
            bindtable = DSBind.Tables[0];
        }
        /**//// <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, con);
            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));

            /**////返回创建的SqlCommand对象
            return cmd;
        }

        /**//// <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 CreateParam(string ParamName, SqlDbType DbType, Int32 Size, ParameterDirection Direction, object Value)
        ...{
            SqlParameter param;

            /**////当参数大小为0时，不使用该参数大小值
            if (Size > 0)
            ...{
                param = new SqlParameter(ParamName, DbType, Size);
            }
            else
            ...{
                /**////当参数大小为0时，不使用该参数大小值
                param = new SqlParameter(ParamName, DbType);
            }

            /**////创建输出类型的参数
            param.Direction = Direction;
            if (!(Direction == ParameterDirection.Output && Value == null))
            ...{
                param.Value = Value;
            }

            /**////返回创建的参数
            return param;
        }

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

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

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

    }
}