经典总结:数据访问基类

 

using System;
using System.Data;
using System.Data.Common;
using System.Collections;
using System.Data.SqlClient;

namespace DataManager.DAL
{
    /// <summary>
    /// DataAccessObject数据访问的基础类
    /// </summary>
    public class DataAccessObject
    {
        /// <summary>
        /// 数据库连接字符串
        /// </summary>
        protected string m_connectionStr = string.Empty;
        /// <summary>
        /// 数据库提供工厂
        /// </summary>
        private DbProviderFactory m_factory;


        // 存储缓存参数的Hashtable
        private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());


        /// <summary>
        /// 构造初始化
        /// </summary>
        /// <param name="connStr">数据库连接字符串</param>
        /// <param name="providerName">数据库提供名称</param>
        protected DataAccessObject(string connStr, string providerName)
        {


            m_connectionStr = connStr;
            try
            {
                m_factory = DbProviderFactories.GetFactory(providerName);
            }
            catch
            {
                throw new Exception("数据提供名称错误");
            }
        }

        /// <summary>
        /// 执行返回单个值的存储过程或sql语句
        /// </summary>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">存储过程名或sql语句</param>
        /// <param name="cmdParameters">数据库查询参数</param>
        /// <returns></returns>
        protected object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParameters)
        {
            DbCommand cmd = m_factory.CreateCommand();
            DbConnection conn = GetConnection();
            PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParameters);
            object val = cmd.ExecuteScalar();
            cmd.Parameters.Clear();
            cmd.Dispose();
            conn.Close();
            return val;
        }

        /// <summary>
        /// 执行不返回数据集的存储过程或sql语句(无事务控制)
        /// </summary>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">存储过程名或sql语句</param>
        /// <param name="cmdParameter">数据库查询参数</param>
        /// <returns></returns>
        protected int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParameter)
        {
            DbConnection conn = GetConnection();
            DbCommand cmd = m_factory.CreateCommand();
            PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParameter);
            int rst = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            cmd.Dispose();
            conn.Close();
            return rst;
        }

        /// <summary>
        /// 执行不返回数据集的存储过程或sql语句(有事务控制)
        /// </summary>
        /// <param name="trans">命令类型</param>
        /// <param name="cmdType">存储过程名或sql语句</param>
        /// <param name="cmdText"></param>
        /// <param name="cmdParameters">数据库查询参数</param>
        /// <returns></returns>
        protected int ExecuteNonQuery(DbTransaction trans, CommandType cmdType, string cmdText, params DbParameter[] cmdParameters)
        {
            DbCommand cmd = m_factory.CreateCommand();
            //当使用事物控制时，使用外部连接
            PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, cmdParameters);
            int rst = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            cmd.Dispose();
            return rst;
        }

        /// <summary>
        /// 执行获取DataReader的存储过程或sql语句(无事务控制)
        /// </summary>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">存储过程名或sql语句</param>
        /// <param name="cmdParameters">数据库查询参数</param>
        /// <returns></returns>
        protected DbDataReader ExecuteReader(CommandType cmdType, string cmdText, params DbParameter[] cmdParameters)
        {
            DbCommand cmd = m_factory.CreateCommand();
            DbConnection conn = GetConnection();

            try
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParameters);
                //关闭DataReader时关闭数据库连接
                DbDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                cmd.Parameters.Clear();
                return rdr;
            }
            catch
            {
                conn.Close();   //如果获取datareader出现错误，则关闭连接
                throw;
            }
            finally
            {
                cmd.Dispose();
            }
        }


        /// <summary>
        /// 创建命令参数
        /// </summary>
        /// <param name="parameterName">参数名称</param>
        /// <param name="dbType">数据类型</param>
        /// <returns></returns>
        protected DbParameter CreateParameter(string parameterName, DbType dbType)
        {
            DbParameter cmdParameter = m_factory.CreateParameter();
            cmdParameter.ParameterName = parameterName;
            cmdParameter.DbType = dbType;
            return cmdParameter;
        }

        /// <summary>
        /// 创建命令参数
        /// </summary>
        /// <param name="parameterName">参数名称</param>
        /// <param name="dbType">数据类型</param>
        /// <param name="parameterDirection">参数方向</param>
        /// <returns></returns>
        protected DbParameter CreateParameter(string parameterName, DbType dbType, ParameterDirection parameterDirection)
        {
            DbParameter cmdParameter = CreateParameter(parameterName, dbType);
            cmdParameter.Direction = parameterDirection;
            return cmdParameter;
        }

        /// <summary>
        /// 创建命令参数
        /// </summary>
        /// <param name="parameterName">参数名称</param>
        /// <param name="dbType">数据类型</param>
        /// <param name="size">参数长度</param>
        /// <returns></returns>
        protected DbParameter CreateParameter(string parameterName, DbType dbType, int size)
        {
            DbParameter cmdParameter = CreateParameter(parameterName, dbType);
            cmdParameter.Size = size;
            return cmdParameter;
        }

        /// <summary>
        /// 创建命令参数
        /// </summary>
        /// <param name="parameterName">参数名称</param>
        /// <param name="dbType">数据类型</param>
        /// <param name="size">参数长度</param>
        /// <param name="value">参数值</param>
        /// <param name="parameterDirection">参数方向</param>
        /// <returns></returns>
        protected DbParameter CreateParameter(string parameterName, DbType dbType, int size, ParameterDirection parameterDirection)
        {
            DbParameter cmdParameter = CreateParameter(parameterName, dbType, size);
            cmdParameter.Direction = parameterDirection;
            return cmdParameter;
        }

        /// <summary>
        /// 获取数据库连接
        /// </summary>
        protected DbConnection GetConnection()
        {
            DbConnection conn = m_factory.CreateConnection();
            conn.ConnectionString = m_connectionStr;
            return conn;
        }

        /// <summary>
        /// 预处理数据库命令
        /// </summary>
        /// <param name="cmd">数据库命令</param>
        /// <param name="conn">数据库连接</param>
        /// <param name="trans">事务对象</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">存储过程名或sql语句</param>
        /// <param name="cmdParms">数据库命令参数</param>
        private void PrepareCommand(DbCommand cmd, DbConnection conn, DbTransaction trans, CommandType cmdType, string cmdText, DbParameter[] cmdParameters)
        {
            if (conn.State != ConnectionState.Open)
                conn.Open();

            cmd.Connection = conn;
            cmd.CommandText = cmdText;

            if (trans != null)
                cmd.Transaction = trans;

            cmd.CommandType = cmdType;

            if (cmdParameters != null)
            {
                foreach (DbParameter parameter in cmdParameters)
                    cmd.Parameters.Add(parameter);
            }
        }


        /// <summary>
        /// 参数缓存
        /// </summary>
        /// <param name="cacheKey">缓存参数对应的KEY</param>
        /// <param name="cmdParms">将要参数数组</param>
        protected void CacheParameters(string cacheKey, params DbParameter[] commandParameters)
        {
            parmCache[cacheKey] = commandParameters;
        }

        /// <summary>
        /// 取出缓存参数
        /// </summary>
        /// <param name="cacheKey">取出参数的KEY</param>
        /// <returns>参数数组</returns>
        public DbParameter[] GetCachedParameters(string cacheKey)
        {
            DbParameter[] cachedParms = (DbParameter[])parmCache[cacheKey];

            if (cachedParms == null)
                return null;

            DbParameter[] clonedParms = new DbParameter[cachedParms.Length];

            for (int i = 0, j = cachedParms.Length; i < j; i++)
                clonedParms[i] = (DbParameter)((ICloneable)cachedParms[i]).Clone();

            return clonedParms;
        }



    }
}