数据访问层DAL(数据库访问抽象类DataProvider)

晒晒数据访问层DAL，看看你的项目数据访问层使用的是什么形式，数据访问性能比较

采用什么样的数据访问形式是软件编码很重要的一个环节，良好的数据访问形式不仅能够提搞代码的执行效率，协作能力，更重要的是对未来程序维护，功能扩展起到至关重要的作用。当然良好的设计模式可以为我们提供很多的选择，但面对实际问题，公司规模小考虑成本，资金投入少，软件逻辑不算复杂，功能较少，部分客户需求只需要单个功能模块，类似小型管理系统，门户网站，crm等，这也为众多IT人事提供了兼职的好机会。借鉴类似程序，cpy下部分代码，小修小改下数据库字段新的软件就大功告成。这种现状在弊端同时也很多程序没有通过完整的测试，部分存在漏洞，维护性不高，导致客户日常投诉反工现象时有发生，弄不好还会引起不必要的麻烦，为此组件一个高效便捷的快速开发框架，集成我们日常生活中的经验是十分有必要的。

这里我就结合几个项目中用到的简单的数据访问层简单和大家共同的学习探讨。

1、常用数据访问我们一般采用的都有：微软自带DBHelper

2、Enterprises Library微软企业库（Microsoft.Practices.EnterpriseLibrary.Common，Microsoft.Practices.EnterpriseLibrary.Data，Microsoft.Practices.ObjectBuilder）

3、这里我和大家共同探讨结合微软DBHelper的自定义的加强版SqlDataProvider.cs

数据库访问抽象类DataProvider.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using System.Configuration;
using System.Data;
using System.Reflection;
using System.Data.OleDb;
namespace DAL
{
     ///<summary>
 /// 数据库访问抽象类
 ///</summary>
     public abstract class DataProvider
     {
         private static DataProvider _instance = null;
         public static DataProvider Instance
         {
             get
             {
                 if (_instance == null)
                  {
                     String strConnectionString = ConfigurationManager.ConnectionStrings["ConnnectionString"].ConnectionString;

                     String strConnectionType = ConfigurationManager.ConnectionStrings["ConnectionType"].ConnectionString;
                     if (strConnectionType.ToLower() == "sqlclient")
                     {
                         strConnectionType = "DAL.SqlDataProvider, DAL";
                     }

                     Type t = Type.GetType(strConnectionType);
                     Type[] paramTypes = new Type[1];
                     paramTypes[0] = typeof(String);

                     Object[] paramArray = new Object[1];
                     paramArray[0] = strConnectionString;

                     _instance = (DataProvider)((ConstructorInfo)t.GetConstructor(paramTypes)).Invoke(paramArray);
                 }
                 return _instance;
             }
         }

         #region 抽象属性和方法

         #region 数据库链接串
         public abstract String ConnectionString { get; }
         #endregion

         #region 执行SQL语句
         public abstract Object GetScalar(String selectSql);
         public abstract DataSet GetDataset(String selectSql);
         public virtual DataSet GetDatasetTrans(SqlTransaction trans, String selectSql) { return null; }
         public virtual DataSet GetDatasetTrans(OleDbTransaction trans, String selectSql) { return null; }
         public virtual DataSet GetDataset(String selectSql, SqlParameter[] para) { return null; }
         public virtual DataSet GetDataset(String selectSql, OleDbParameter[] para) { return null; }
         public virtual DataSet GetDatasetTrans(SqlTransaction trans, String selectSql, SqlParameter[] para) { return null; }
         public virtual DataSet GetDatasetTrans(OleDbTransaction trans, String selectSql, OleDbParameter[] para) { return null; }
         public abstract void Execute(String noneQuery);
         public virtual void Execute(String noneQuery, SqlParameter[] para) { }
         public virtual void Execute(String noneQuery, OleDbParameter[] para) { }
         public abstract IDataReader GetReader(String selectSql);
         public virtual IDataReader GetReaderTrans(SqlTransaction trans, String selectSql) { return null; }
         public virtual IDataReader GetReaderTrans(OleDbTransaction trans, String selectSql) { return null; }
         public virtual IDataReader GetReader(String selectSql, SqlParameter[] para) { return null; }
         public virtual IDataReader GetReader(String selectSql, OleDbParameter[] para) { return null; }
         public virtual IDataReader GetReaderTrans(SqlTransaction trans, String selectSql, SqlParameter[] para) { return null; }
         public virtual IDataReader GetReaderTrans(OleDbTransaction trans, String selectSql, OleDbParameter[] para) { return null; }
         #endregion

         #region 执行存储过程
         public abstract void ExecuteSp(String spName);
         public virtual void ExecuteSp(SqlTransaction trans, String spName) { }
         public virtual void ExecuteSp(OleDbTransaction trans, String spName) { }
         public virtual void ExecuteSp(String spName, SqlParameter[] para) { }
         public virtual void ExecuteSp(String spName, OleDbParameter[] para) { }
         public virtual void ExecuteSp(SqlTransaction trans, String spName, SqlParameter[] para) { }
         public virtual void ExecuteSp(OleDbTransaction trans, String spName, OleDbParameter[] para) { }
         public abstract IDataReader GetReaderBySp(String spName);
         public virtual IDataReader GetReaderBySp(String spName, SqlParameter[] para) { return null; }
         public virtual IDataReader GetReaderBySp(String spName, OleDbParameter[] para) { return null; }
         public abstract Object GetScalarBySp(String spName);
         public virtual Object GetScalarBySp(String spName, SqlParameter[] para) { return null; }
         public virtual Object GetScalarBySp(String spName, OleDbParameter[] para) { return null; }
         public abstract DataSet GetDatasetBySp(String spName);
         public virtual DataSet GetDatasetBySp(String spName, SqlParameter[] para) { return null; }
         public virtual DataSet GetDatasetBySp(String spName, OleDbParameter[] para) { return null; }
         #endregion

         #endregion
     }
 }

继承类SqlDataProvider：

using System;
sing System.Collections.Generic;
sing System.Linq;
sing System.Text;
sing System.Data;
sing System.Data.SqlClient;
amespace DAL

   public class SqlDataProvider : DataProvider
   {
       private String _connectionString = String.Empty;

       public SqlDataProvider(String connString)
       {
           _connectionString = connString;
       }

       #region 实现抽象方法

       #region 数据库链接串
       public override String ConnectionString
       {
           get
           {
               return _connectionString;
           }
       }

       #endregion

       #region 执行SQL语句

       ///<summary>
// 执行查询获取单值
//</summary>
//<param name="selectSql">查询语句</param>
//<returns>返回Object</returns>
      public override Object GetScalar(String selectSql)
       {
           return SqlHelper.ExecuteScalar(_connectionString,
               CommandType.Text, selectSql);
       }

       ///<summary>
// 根据查询语句获取数据集
//</summary>
//<param name="selectSql">查询语句</param>
//<returns>返回数据集</returns>
       public override DataSet GetDataset(String selectSql)
       {
           if (selectSql == null) throw new ArgumentNullException("selectSql");

           DataSet ds = new DataSet();
           SqlHelper.FillDataset(_connectionString, CommandType.Text, selectSql, ds, null);
           return ds;
       }

       ///<summary>
// 根据查询语句获取数据集
//</summary>
//<param name="trans">事务</param>
//<param name="selectSql">查询语句</param>
//<returns>返回数据集</returns>
       public override DataSet GetDatasetTrans(SqlTransaction trans, String selectSql)
       {
           if (selectSql == null) throw new ArgumentNullException("selectSql");

           DataSet ds = new DataSet();
           SqlHelper.FillDataset(trans, CommandType.Text, selectSql, ds, null);
           return ds;
       }

       ///<summary>
// 根据带参数的查询语句获取数据集
//</summary>
//<param name="selectSql">查询语句</param>
//<param name="para">参数列表</param>
//<returns>返回数据集</returns>
       public override DataSet GetDataset(String selectSql, SqlParameter[] para)
       {
           if (selectSql == null) throw new ArgumentNullException("selectSql");
           if (para == null) throw new ArgumentNullException("para");

          DataSet ds = new DataSet();
            SqlHelper.FillDataset(_connectionString, CommandType.Text, selectSql, ds, null, para);
            return ds;
        }

        ///<summary>
/// 根据带参数的查询语句获取数据集
///</summary>
///<param name="trans">事务</param>
///<param name="selectSql">查询语句</param>
///<param name="para">参数列表</param>
///<returns>返回数据集</returns>
        public override DataSet GetDatasetTrans(SqlTransaction trans, String selectSql, SqlParameter[] para)
        {
            if (selectSql == null) throw new ArgumentNullException("selectSql");
            if (para == null) throw new ArgumentNullException("para");

           DataSet ds = new DataSet();
           SqlHelper.FillDataset(trans, CommandType.Text, selectSql, ds, null, para);
           return ds;
       }

       ///<summary>
// 在某个数据库连接对象上执行查询语句获取数据集
//</summary>
//<param name="cn">数据库连接对象</param>
//<param name="selectSql">查询语句</param>
//<returns>返回数据集</returns>
       public static DataSet GetDataset(SqlConnection conn, String selectSql)
       {
           if (conn == null) throw new ArgumentNullException("conn");
           if (selectSql == null) throw new ArgumentNullException("selectSql");

           DataSet ds = new DataSet();
           SqlHelper.FillDataset(conn, CommandType.Text, selectSql, ds, null);
           return ds;
       }

       ///<summary>
// 执行非查询语句
//</summary>
//<param name="noneQuery">非查询sql语句</param>
       public override void Execute(String noneQuery)
       {
           if (noneQuery == null) throw new ArgumentNullException("noneQuery");

           SqlHelper.ExecuteNonQuery(_connectionString, CommandType.Text, noneQuery);
       }

       ///<summary>
// 执行非查询语句
//</summary>
//<param name="noneQuery">非查询sql语句</param>
//<param name="para">参数列表</param>
       public override void Execute(String noneQuery, SqlParameter[] para)
       {
           if (noneQuery == null) throw new ArgumentNullException("noneQuery");
           if (para == null) throw new ArgumentNullException("para");

           SqlHelper.ExecuteNonQuery(_connectionString, CommandType.Text, noneQuery, para);
       }

       ///<summary>
// 执行查询语句获取Reader对象
//</summary>
//<param name="selectSql">查询语句</param>
//<returns>返回DataReader</returns>
       public override IDataReader GetReader(String selectSql)
       {
           if (selectSql == null) throw new ArgumentNullException("selectSql");

           return SqlHelper.ExecuteReader(_connectionString, CommandType.Text, selectSql);
       }

       ///<summary>
// 执行查询语句获取Reader对象
//</summary>
/<param name="trans">事务</param>
//<param name="selectSql">查询语句</param>
//<returns>返回DataReader</returns>
       public override IDataReader GetReaderTrans(SqlTransaction trans, String selectSql)
       {
           if (selectSql == null) throw new ArgumentNullException("selectSql");

           return SqlHelper.ExecuteReader(trans, CommandType.Text, selectSql);
       }

       ///<summary>
// 执行查询语句获取Reader对象
//</summary>
//<param name="selectSql">查询语句</param>
//<param name="para">参数列表</param>
//<returns>返回DataReader</returns>
       public override IDataReader GetReader(String selectSql, SqlParameter[] para)
       {
           if (selectSql == null) throw new ArgumentNullException("selectSql");
          if (para == null) throw new ArgumentNullException("para");

           return SqlHelper.ExecuteReader(_connectionString, CommandType.Text, selectSql, para);
       }

       ///<summary>
// 执行查询语句获取Reader对象
//</summary>
//<param name="trans">事务</param>
//<param name="selectSql">查询语句</param>
//<param name="para">参数列表</param>
//<returns>返回DataReader</returns>
       public override IDataReader GetReaderTrans(SqlTransaction trans, String selectSql, SqlParameter[] para)
       {
           if (selectSql == null) throw new ArgumentNullException("selectSql");
           if (para == null) throw new ArgumentNullException("para");

           return SqlHelper.ExecuteReader(trans, CommandType.Text, selectSql, para);
       }

       #endregion

       #region 执行存储过程
       ///<summary>
// 执行非查询存储过程
//</summary>
//<param name="spName">存储过程名称</param>
       public override void ExecuteSp(String spName)
      {
           if (spName == null) throw new ArgumentNullException("spName");

           SqlHelper.ExecuteNonQuery(_connectionString, CommandType.StoredProcedure, spName);
       }

       ///<summary>
// 执行非查询存储过程
//</summary>
//<param name="trans">事务对象</param>
/<param name="spName">存储过程名称</param>
       public override void ExecuteSp(SqlTransaction trans, String spName)
       {
           if (trans == null) throw new ArgumentNullException("trans");
           if (spName == null) throw new ArgumentNullException("spName");

          SqlHelper.ExecuteNonQuery(trans, CommandType.StoredProcedure, spName);
       }

       ///<summary>
// 执行非查询存储过程
//</summary>
//<param name="spName">存储过程名称</param>
//<param name="para">参数列表</param>
       public override void ExecuteSp(String spName, SqlParameter[] para)
       {
           if (spName == null) throw new ArgumentNullException("spName");
           if (para == null) throw new ArgumentNullException("para");

           SqlHelper.ExecuteNonQuery(_connectionString, CommandType.StoredProcedure, spName, para);
       }

      /// 执行非查询存储过程
//</summary>
//<param name="trans">事务对象</param>
//<param name="spName">存储过程名称</param>
//<param name="para">参数列表</param>
       public override void ExecuteSp(SqlTransaction trans, String spName, SqlParameter[] para)
       {
           if (trans == null) throw new ArgumentNullException("trans");
           if (spName == null) throw new ArgumentNullException("spName");
           if (para == null) throw new ArgumentNullException("para");

           SqlHelper.ExecuteNonQuery(trans, CommandType.StoredProcedure,
               spName, para);
       }

       ///<summary>
// 执行查询存储过程获取Reader对象
//</summary>
//<param name="spName">存储过程名称</param>
//<returns>返回DataReader</returns>
       public override IDataReader GetReaderBySp(String spName)
       {
           if (spName == null) throw new ArgumentNullException("spName");
           return SqlHelper.ExecuteReader(_connectionString,
               CommandType.StoredProcedure, spName);
       }

       ///<summary>
// 执行查询存储过程获取Reader对象
//</summary>
//<param name="spName">存储过程名称</param>
//<param name="para">参数列表</param>
//<returns>返回DataReader</returns>
       public override IDataReader GetReaderBySp(String spName, SqlParameter[] para)
       {
           return SqlHelper.ExecuteReader(_connectionString,
               CommandType.StoredProcedure, spName, para);
       }

      ///<summary>
// 执行查询存储过程获取单值
//</summary>
//<param name="spName">存储过程名称</param>
//<returns>返回Object</returns>
       public override Object GetScalarBySp(String spName)
       {
           return SqlHelper.ExecuteScalar(_connectionString,
               CommandType.StoredProcedure, spName);
       }

       ///<summary>
// 执行查询存储过程获取单值
//</summary>
//<param name="spName">存储过程名称</param>
//<param name="para">参数列表</param>
//<returns>返回Object</returns>
       public override Object GetScalarBySp(String spName, SqlParameter[] para)
      {
           return SqlHelper.ExecuteScalar(_connectionString,
              CommandType.StoredProcedure, spName, para);
       }

       ///<summary>
// 根据存储过程获取数据集
//</summary>
//<param name="spName">存储过程</param>
//<returns>返回数据集</returns>
       public override DataSet GetDatasetBySp(String spName)
       {
           if (spName == null) throw new ArgumentNullException("spName");

          DataSet ds = new DataSet();
           SqlHelper.FillDataset(_connectionString, CommandType.StoredProcedure, spName, ds, null);
           return ds;
      }
       ///<summary>
// 根据带参数的存储过程获取数据集
//</summary>
//<param name="spName">存储过程</param>
//<param name="para">参数列表</param>
//<returns>返回数据集</returns>
       public override DataSet GetDatasetBySp(String spName, SqlParameter[] para)
       {
           if (spName == null) throw new ArgumentNullException("spName");
          if (para == null) throw new ArgumentNullException("para");

           DataSet ds = new DataSet();
           SqlHelper.FillDataset(_connectionString, CommandType.StoredProcedure, spName, ds, null, para);
          return ds;
       }
       #endregion

       #endregion
   }

微软本身是的SqlHelper类提供高性能可扩充的数据库访问方法，代码就不啰嗦大家都懂的，通过集成和改造对数据访问的安全性，扩展性做进一步的伸展

测试 同时加载1w条数据试一试，方法执行时间，忽略浏览器加载时间

改造数据访问：

方法执行时间

企业库：

方法执行时间

普通DBHlper:

方法执行时间

同时加载10W条数据试一试：

改造后10W条数据访问时间：

企业库10W数据访问时间：

普通DBHelper,10W条数据访问时间：

当然了测试和机器配置也相关，以上数据仅供参考，不一定准确，还有很多地方不是很完善，你的项目采用的是什么数据交互模式来？有没有更好的意见和建议，期待达人们的意见和建议。