搭建一套自己实用的.net架构(3)【ORM-Dapper+DapperExtensions】

现在成熟的ORM比比皆是，这里只介绍Dapper的使用（最起码我在使用它，已经运用到项目中，小伙伴们反馈还可以）。

优点：

1、开源、轻量、小巧、上手容易。

2、支持的数据库还蛮多的， Mysql,SqlLite,Sqlserver,Oracle等一系列的数据库。

3、Dapper原理通过Emit反射IDataReader的序列队列来快速的得到和产生对象。性能貌似很牛逼的样子

缺点：

作为一款ORM太过于轻量级了，根据对象自动生成sql的功能还是空白，需要自己来扩展，

当然这也是优点，  好声音的导师们经常说某人就是张白纸……

因此针对Dapper已经有很多成熟的扩展项目了，Dapper.Rainbow、Dapper.Contrib，DapperExtensions。

我们这里介绍的是DapperExtensions。

dapper-dot-net源码：https://github.com/StackExchange/dapper-dot-net   （更新频率快，项目包含了各种除了Dapper-Extensions的 扩展项目）

Dapper-Extensions 源码：https://github.com/tmsmith/Dapper-Extensions

Dapper-Extensions的优点：

1、开源

2、针对Dapper封装了常用的CRUD方法，有独立的查询语法。

3、需要映射的实体类本身0配置，无需加特性什么的。是通过独立的映射类来处理，可以设置类映射到DB的别名，字段的别名等等。

Dapper-Extensions的缺点：

1、好几年没更新了

2、不支持oracle（木有oracle的方言，已经搞定）

3、不能同时支持多种数据库（已经搞定）

4、部分代码有些bug（发现的都搞定了）

下面先简单介绍一下Dapper的基本语法。

Dapper就一个.cs文件，可以放到项目代码中直接编译，也可以直接引用DLL文件。

Dapper对DB的操作依赖于Connection，为了支持多库，咱们用 IDbConnection conn

using (IDbConnection conn = GetConnection())
    {
        const string query = "select * from XO order by id desc";
        return conn.Query<XOEntity>(query,null);
    }

下面是带参数的语法

int xoID=666; //变量主键
 using (IDbConnection conn = GetConnection())
    {
        const string query = "select * from XO where Id=@MyID";
        return conn.Query<XOEntity>(query, new { MyID = xoID});

    }

各种方法都重载了事务的操作，一般的数据库操作都支持。但是每次执行都需要传递sql，而且每次都要使用Using，看着不爽啊， 这……

好吧下面简单介绍下使用Dapper-Extensions的基本语法（在Dapper-Extensions  的基础上用了Repository模式，代码效果如下）。

            //实体类
            DemoEntity entity = new DemoEntity();

            //根据实体主键删除
            this.Delete<DemoEntity>(entity);

            //根据主键ID删除
            this.Delete<DemoEntity>();

            //增加
            this.Insert<DemoEntity>(entity);

            //更新
            bool result = this.Update<DemoEntity>(entity);

            //根据主键返回实体
            entity = this.GetById<DemoEntity>();

            //返回 行数
            this.Count<DemoEntity>(new { ID =  });

            //查询所有
            IEnumerable<DemoEntity> list = this.GetAll<DemoEntity>();

            IList<ISort> sort = new List<ISort>();
            sort.Add(new Sort { PropertyName = "ID", Ascending = false });

            //条件查询
            list = this.GetList<DemoEntity>(new { ID = , Name = "" }, sort);

            //orm 拼接条件 查询
            IList<IPredicate> predList = new List<IPredicate>();
            predList.Add(Predicates.Field<DemoEntity>(p => p.Name, Operator.Like, "不知道%"));
            predList.Add(Predicates.Field<DemoEntity>(p => p.ID, Operator.Eq, ));
            IPredicateGroup predGroup = Predicates.Group(GroupOperator.And, predList.ToArray());

            list = this.GetList<DemoEntity>(predGroup);

            //分页查询
            long allRowsCount = ;
            this.GetPageList<DemoEntity>(, , out allRowsCount, new { ID =  }, sort);

在说ORM之前，还是要说一下HY.DataAccess这个模块

aaarticlea/png;base64,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" alt="" />

这个模块是对数据访问提供的一个Helper的功能，里面包含了 各种DB的SqlHelper，分页。

DBHelper 都继承自IDBHelper.cs

using System.Data.Common;
using System.Data;

namespace HY.DataAccess
{
    /// <summary>
    /// 提供对数据库的基本操作，连接字符串需要在数据库配置。
    /// </summary>
    public interface IDBHelper
    {

        /// <summary>
        /// 生成分页SQL语句
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="selectSql"></param>
        /// <param name="sqlCount"></param>
        /// <param name="orderBy"></param>
        /// <returns></returns>
        string GetPagingSql(int pageIndex, int pageSize, string selectSql, string sqlCount, string orderBy);

        /// <summary>
        /// 开始一个事务
        /// </summary>
        /// <returns></returns>
        DbTransaction BeginTractionand();

        /// <summary>
        /// 开始一个事务
        /// </summary>
        /// <param name="connKey">数据库连接字符key</param>
        DbTransaction BeginTractionand(string connKey);

        /// <summary>
        /// 回滚事务
        /// </summary>
        /// <param name="dbTransaction">要回滚的事务</param>
        void RollbackTractionand(DbTransaction dbTransaction);

        /// <summary>
        /// 结束并确认事务
        /// </summary>
        /// <param name="dbTransaction">要结束的事务</param>
        void CommitTractionand(DbTransaction dbTransaction);

        #region DataSet

        /// <summary>
        /// 执行sql语句,ExecuteDataSet 返回DataSet
        /// </summary>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        DataSet ExecuteDataSet(string commandText, CommandType commandType);

        /// <summary>
        /// 执行sql语句,ExecuteDataSet 返回DataSet
        /// </summary>
        /// <param name="connKey">数据库连接字符key</param>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        DataSet ExecuteDataSet(string connKey, string commandText, CommandType commandType);

        /// <summary>
        /// 执行sql语句,ExecuteDataSet 返回DataSet
        /// </summary>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        /// <param name="parameterValues">参数</param>
        DataSet ExecuteDataSet(string commandText, CommandType commandType, params DbParameter[] parameterValues);

        /// <summary>
        /// 执行sql语句,ExecuteDataSet 返回DataSet
        /// </summary>
        /// <param name="connKey">数据库连接字符key</param>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        /// <param name="parameterValues">参数</param>
        DataSet ExecuteDataSet(string connKey, string commandText, CommandType commandType, params DbParameter[] parameterValues);

        #endregion

        #region ExecuteNonQuery

        /// <summary>
        /// 执行sql语句,返回影响的行数
        /// </summary>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        int ExecuteNonQuery(string commandText, CommandType commandType);

        /// <summary>
        /// 执行sql语句,返回影响的行数
        /// </summary>
        /// <param name="connKey">数据库连接字符key</param>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        int ExecuteNonQuery(string connKey, string commandText, CommandType commandType);

        /// <summary>
        /// 执行sql语句,返回影响的行数
        /// </summary>
        /// <param name="trans">事务对象</param>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        int ExecuteNonQuery(DbTransaction trans, string commandText, CommandType commandType);

        /// <summary>
        /// 执行sql语句,返回影响的行数
        /// </summary>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        /// <param name="parameterValues">参数</param>
        int ExecuteNonQuery(string commandText, CommandType commandType, params DbParameter[] parameterValues);

        /// <summary>
        /// 执行sql语句,返回影响的行数
        /// </summary>
        /// <param name="connKey">数据库连接字符key</param>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        /// <param name="parameterValues">参数</param>
        int ExecuteNonQuery(string connKey, string commandText, CommandType commandType, params DbParameter[] parameterValues);

        /// <summary>
        /// 执行sql语句,返回影响的行数
        /// </summary>
        /// <param name="trans">事务对象</param>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        /// <param name="parameterValues">参数</param>
        int ExecuteNonQuery(DbTransaction trans, string commandText, CommandType commandType, params DbParameter[] parameterValues);

        #endregion

        #region IDataReader

        /// <summary>
        /// 执行sql语句,ExecuteReader 返回IDataReader
        /// </summary>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        IDataReader ExecuteReader(string commandText, CommandType commandType);

        /// <summary>
        /// 执行sql语句,ExecuteReader 返回IDataReader
        /// </summary>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        /// <param name="parameterValues">参数</param>
        IDataReader ExecuteReader(string commandText, CommandType commandType, params DbParameter[] parameterValues);

        /// <summary>
        /// 执行sql语句,ExecuteReader 返回IDataReader
        /// </summary>
        /// <param name="connKey">数据库连接字符key</param>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        IDataReader ExecuteReader(string connKey, string commandText, CommandType commandType);

        /// <summary>
        /// 执行sql语句,ExecuteReader 返回IDataReader
        /// </summary>
        /// <param name="connKey">数据库连接字符key</param>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        /// <param name="parameterValues">参数</param>
        IDataReader ExecuteReader(string connKey, string commandText, CommandType commandType, params DbParameter[] parameterValues);

        #endregion

        #region ExecuteScalar

        /// <summary>
        /// 执行sql语句,ExecuteScalar 返回第一行第一列的值
        /// </summary>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        object ExecuteScalar(string commandText, CommandType commandType);

        /// <summary>
        /// 执行sql语句,ExecuteScalar 返回第一行第一列的值
        /// </summary>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        /// <param name="parameterValues">参数</param>
        object ExecuteScalar(string commandText, CommandType commandType, params DbParameter[] parameterValues);

        /// <summary>
        /// 执行sql语句,ExecuteScalar 返回第一行第一列的值
        /// </summary>
        /// <param name="trans">事务</param>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        object ExecuteScalar(DbTransaction trans, string commandText, CommandType commandType);

        /// <summary>
        /// 执行sql语句,ExecuteScalar 返回第一行第一列的值
        /// </summary>
        /// <param name="connKey">数据库连接字符key</param>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        object ExecuteScalar(string connKey, string commandText, CommandType commandType);

        /// <summary>
        /// 执行sql语句,ExecuteScalar 返回第一行第一列的值
        /// </summary>
        /// <param name="connKey">数据库连接字符key</param>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        /// <param name="parameterValues">参数</param>
        object ExecuteScalar(string connKey, string commandText, CommandType commandType, params DbParameter[] parameterValues);

        /// <summary>
        /// 执行sql语句,ExecuteScalar 返回第一行第一列的值
        /// </summary>
        /// <param name="trans">事务</param>
        /// <param name="commandText">sql语句</param>
        /// <param name="commandType"></param>
        /// <param name="parameterValues">参数</param>
        /// <returns></returns>
        object ExecuteScalar(DbTransaction trans, string commandText, CommandType commandType, params DbParameter[] parameterValues);
        #endregion

    }
}

IDBSession.cs 对数据访问对象的定义

using System;
using System.Data;

namespace HY.DataAccess
{

    /// <summary>
    /// 数据库接口
    /// </summary>
    public interface IDatabase
    {
        IDbConnection Connection { get; }

        DatabaseType DatabaseType { get; }

        string ConnKey { get; }
    }

    /// <summary>
    /// 数据库类对象
    /// </summary>
    public class Database : IDatabase
    {
        public IDbConnection Connection { get; private set; }

        public DatabaseType DatabaseType { get; private set; }

        public string ConnKey { get; set; }

        public Database(IDbConnection connection)
        {
            Connection = connection;
        }

        public Database(DatabaseType dbType, string connKey)
        {
            DatabaseType = dbType;
            ConnKey = connKey;
            Connection = SqlConnectionFactory.CreateSqlConnection(dbType, connKey);
        }

    }

    /// <summary>
    /// 数据连接事务的Session接口
    /// </summary>
    public interface IDBSession : IDisposable
    {
        string ConnKey { get; }
        DatabaseType DatabaseType { get; }
        IDbConnection Connection { get; }
        IDbTransaction Transaction { get; }
        IDbTransaction Begin(IsolationLevel isolation = IsolationLevel.ReadCommitted);
        void Commit();
        void Rollback();
    }
}

SqlConnectionFactory.cs 这个类是采用工厂模式创建DB连接的封装，代码如下：

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;

namespace HY.DataAccess
{

    public enum DatabaseType
    {
        SqlServer,
        MySql,
        Oracle,
        DB2
    }

    public class SqlConnectionFactory
    {
        public static IDbConnection CreateSqlConnection(DatabaseType dbType, string strKey)
        {
            IDbConnection connection = null;
            string strConn = ConfigurationManager.ConnectionStrings[strKey].ConnectionString;

            switch (dbType)
            {
                case DatabaseType.SqlServer:
                    connection = new System.Data.SqlClient.SqlConnection(strConn);
                    break;
                case DatabaseType.MySql:
                    //connection = new MySql.Data.MySqlClient.MySqlConnection(strConn);
                    //break;
                case DatabaseType.Oracle:
                    //connection = new Oracle.DataAccess.Client.OracleConnection(strConn);
                    connection = new System.Data.OracleClient.OracleConnection(strConn);
                    break;
                case DatabaseType.DB2:
                    connection = new System.Data.OleDb.OleDbConnection(strConn);
                    break;
            }
            return connection;
        }
    }
}

ORM也不是万能的，比如做大数据的批量插入什么的，还是需要SqlHelper，加上有的人就喜欢DataTable或者DataSet。

所以SqlHelper作为根基，ORM作为辅助，万无一失啊。

下面说说ORM这块的实现方式。见下截图

aaarticlea/png;base64,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" alt="" />

IDataServiceRepository.cs（提供业务层使用，里面的方法不支持传递sql，包含sql的语句最好还是放在数据层操作的好）

using System.Collections.Generic;
using System.Data;
using DapperExtensions;
using HY.DataAccess;

namespace HY.ORM
{
    public interface IDataServiceRepository
    {
        IDBSession DBSession { get; }

        T GetById<T>(dynamic primaryId) where T : class;
        IEnumerable<T> GetByIds<T>(IList<dynamic> ids) where T : class;
        IEnumerable<T> GetAll<T>() where T : class;

        int Count<T>(object predicate, bool buffered = false) where T : class;

        //lsit
        IEnumerable<T> GetList<T>(object predicate = null, IList<ISort> sort = null, bool buffered = false) where T : class;

        IEnumerable<T> GetPageList<T>(int pageIndex, int pageSize, out long allRowsCount, object predicate = null, IList<ISort> sort = null, bool buffered = true) where T : class;

        dynamic Insert<T>(T entity, IDbTransaction transaction = null) where T : class;
        bool InsertBatch<T>(IEnumerable<T> entityList, IDbTransaction transaction = null) where T : class;
        bool Update<T>(T entity, IDbTransaction transaction = null) where T : class;
        bool UpdateBatch<T>(IEnumerable<T> entityList, IDbTransaction transaction = null) where T : class;
        int Delete<T>(dynamic primaryId, IDbTransaction transaction = null) where T : class;
        int DeleteList<T>(object predicate, IDbTransaction transaction = null) where T : class;
        bool DeleteBatch<T>(IEnumerable<dynamic> ids, IDbTransaction transaction = null) where T : class;
    }
}

IDataRepository.cs（提供数据层使用，继承了上面的IDataServiceRepository，支持传入sql）

using System;
using System.Collections.Generic;
using System.Data;
using Dapper;
using HY.DataAccess;

namespace HY.ORM
{
    public interface IDataRepository : IDataServiceRepository
    {
        IDBSession DBSession { get; }

        IEnumerable<T> Get<T>(string sql, dynamic param = null, bool buffered = true) where T : class;
        IEnumerable<dynamic> Get(string sql, dynamic param = null, bool buffered = true);
        IEnumerable<TReturn> Get<TFirst, TSecond, TReturn>(string sql, Func<TFirst, TSecond, TReturn> map,
            dynamic param = null, IDbTransaction transaction = null, bool buffered = true,
            string splitOn = "Id", int? commandTimeout = null);

         IEnumerable<TReturn> Get<TFirst, TSecond,TThird, TReturn>(string sql, Func<TFirst, TSecond,TThird, TReturn> map,
            dynamic param = null, IDbTransaction transaction = null, bool buffered = true,
            string splitOn = "Id", int? commandTimeout = null);

        SqlMapper.GridReader GetMultiple(string sql, dynamic param = null, IDbTransaction transaction = null,
            int? commandTimeout = null, CommandType? commandType = null);

        IEnumerable<T> GetPage<T>(int pageIndex, int pageSize, out long allRowsCount, string sql, dynamic param = null, string allRowsCountSql=null,  dynamic allRowsCountParam = null, bool buffered = true) where T : class;

        Int32 Execute(string sql, dynamic param = null, IDbTransaction transaction = null);

    }
}

RepositoryServiceBase.cs（IDataServiceRepository的实现类）

using System.Collections.Generic;
using System.Data;
using System.Linq;
using Dapper;
using DapperExtensions;
using HY.DataAccess;

namespace HY.ORM
{
    public class RepositoryServiceBase : IDataServiceRepository
    {
        public RepositoryServiceBase()
        {
        }
        public RepositoryServiceBase(IDBSession dbSession)
        {
            DBSession = dbSession;
        }

        public IDBSession DBSession { get; private set; }

        public void SetDBSession(IDBSession dbSession)
        {
            DBSession = dbSession;
        }

        /// <summary>
        /// 根据Id获取实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="primaryId"></param>
        /// <returns></returns>
        public T GetById<T>(dynamic primaryId) where T : class
        {
            return DBSession.Connection.Get<T>(primaryId as object, databaseType: DBSession.DatabaseType);
        }

        /// <summary>
        /// 根据多个Id获取多个实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="ids"></param>
        /// <returns></returns>
        public IEnumerable<T> GetByIds<T>(IList<dynamic> ids) where T : class
        {
            var tblName = string.Format("dbo.{0}", typeof(T).Name);
            var idsin = string.Join(",", ids.ToArray<dynamic>());
            var sql = "SELECT * FROM @table WHERE Id in (@ids)";
            IEnumerable<T> dataList = DBSession.Connection.Query<T>(sql, new { table = tblName, ids = idsin });
            return dataList;
        }

        /// <summary>
        /// 获取全部数据集合
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public IEnumerable<T> GetAll<T>() where T : class
        {
            return DBSession.Connection.GetList<T>(databaseType: DBSession.DatabaseType);
        }

        /// <summary>
        /// 统计记录总数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="predicate"></param>
        /// <param name="buffered"></param>
        /// <returns></returns>
        public int Count<T>(object predicate, bool buffered = false) where T : class
        {
            return DBSession.Connection.Count<T>(predicate, databaseType: DBSession.DatabaseType);
        }

        /// <summary>
        /// 查询列表数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="predicate"></param>
        /// <param name="sort"></param>
        /// <param name="buffered"></param>
        /// <returns></returns>
        public IEnumerable<T> GetList<T>(object predicate = null, IList<ISort> sort = null,
            bool buffered = false) where T : class
        {
            return DBSession.Connection.GetList<T>(predicate, sort, null, null, buffered, databaseType: DBSession.DatabaseType);
        }

        /// <summary>
        /// 分页
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="allRowsCount"></param>
        /// <param name="predicate"></param>
        /// <param name="sort"></param>
        /// <param name="buffered"></param>
        /// <returns></returns>
        public IEnumerable<T> GetPageList<T>(int pageIndex, int pageSize, out long allRowsCount,
            object predicate = null, IList<ISort> sort = null, bool buffered = true) where T : class
        {
            if (sort == null)
            {
                sort = new List<ISort>();
            }
            IEnumerable<T> entityList = DBSession.Connection.GetPage<T>(predicate, sort, pageIndex, pageSize, null, null, buffered, databaseType: DBSession.DatabaseType);
            allRowsCount = DBSession.Connection.Count<T>(predicate, databaseType: DBSession.DatabaseType);
            return entityList;
        }

        /// <summary>
        /// 插入单条记录
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="transaction"></param>
        /// <returns></returns>
        public dynamic Insert<T>(T entity, IDbTransaction transaction = null) where T : class
        {
            dynamic result = DBSession.Connection.Insert<T>(entity, transaction, databaseType: DBSession.DatabaseType);
            return result;
        }

        /// <summary>
        /// 更新单条记录
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="transaction"></param>
        /// <returns></returns>
        public bool Update<T>(T entity, IDbTransaction transaction = null) where T : class
        {
            bool isOk = DBSession.Connection.Update<T>(entity, transaction, databaseType: DBSession.DatabaseType);
            return isOk;
        }

        /// <summary>
        /// 删除单条记录
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="primaryId"></param>
        /// <param name="transaction"></param>
        /// <returns></returns>
        public int Delete<T>(dynamic primaryId, IDbTransaction transaction = null) where T : class
        {
            var entity = GetById<T>(primaryId);
            var obj = entity as T;
            int isOk = DBSession.Connection.Delete<T>(obj, databaseType: DBSession.DatabaseType);
            return isOk;
        }

        /// <summary>
        /// 删除单条记录
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="predicate"></param>
        /// <param name="transaction"></param>
        /// <returns></returns>
        public int DeleteList<T>(object predicate = null, IDbTransaction transaction = null) where T : class
        {
            return DBSession.Connection.Delete<T>(predicate, transaction, databaseType: DBSession.DatabaseType);
        }

        /// <summary>
        /// 批量插入功能
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entityList"></param>
        /// <param name="transaction"></param>
        public bool InsertBatch<T>(IEnumerable<T> entityList, IDbTransaction transaction = null) where T : class
        {
            bool isOk = false;
            foreach (var item in entityList)
            {
                Insert<T>(item, transaction);
            }
            isOk = true;
            return isOk;
        }

        /// <summary>
        /// 批量更新（）
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entityList"></param>
        /// <param name="transaction"></param>
        /// <returns></returns>
        public bool UpdateBatch<T>(IEnumerable<T> entityList, IDbTransaction transaction = null) where T : class
        {
            bool isOk = false;
            foreach (var item in entityList)
            {
                Update<T>(item, transaction);
            }
            isOk = true;
            return isOk;
        }

        /// <summary>
        /// 批量删除
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="ids"></param>
        /// <param name="transaction"></param>
        /// <returns></returns>
        public bool DeleteBatch<T>(IEnumerable<dynamic> ids, IDbTransaction transaction = null) where T : class
        {
            bool isOk = false;
            foreach (var id in ids)
            {
                Delete<T>(id, transaction);
            }
            isOk = true;
            return isOk;
        }

    }
}

RepositoryBase.cs（IDataRepository的实现类）

using System;
using System.Collections.Generic;
using System.Data;
using Dapper;
using DapperExtensions;
using HY.DataAccess;

namespace HY.ORM
{
    /// <summary>
    /// Repository基类
    /// </summary>
    public class RepositoryBase : RepositoryServiceBase, IDataRepository
    {

        public RepositoryBase()
        {
        }

        public new void SetDBSession(IDBSession dbSession)
        {
            base.SetDBSession(dbSession);
        }

        public RepositoryBase(IDBSession dbSession)
            : base(dbSession)
        {
        }

        /// <summary>
        /// 根据条件筛选出数据集合
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <param name="buffered"></param>
        /// <returns></returns>
        public IEnumerable<T> Get<T>(string sql, dynamic param = null, bool buffered = true) where T : class
        {

            return DBSession.Connection.Query<T>(sql, param as object, DBSession.Transaction, buffered);
        }

        /// <summary>
        /// 根据条件筛选数据集合
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <param name="buffered"></param>
        /// <returns></returns>
        public IEnumerable<dynamic> Get(string sql, dynamic param = null, bool buffered = true)
        {
            return DBSession.Connection.Query(sql, param as object, DBSession.Transaction, buffered);
        }

        /// <summary>
        /// 分页查询
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="allRowsCount"></param>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <param name="allRowsCountSql"></param>
        /// <param name="allRowsCountParam"></param>
        /// <param name="buffered"></param>
        /// <returns></returns>
        public IEnumerable<T> GetPage<T>(int pageIndex, int pageSize, out long allRowsCount, string sql, dynamic param = null, string allRowsCountSql = null, dynamic allRowsCountParam = null, bool buffered = true) where T : class
        {
            IEnumerable<T> entityList = DBSession.Connection.GetPage<T>(pageIndex, pageSize, out allRowsCount, sql, param as object, allRowsCountSql, null, null, buffered, databaseType: DBSession.DatabaseType);
            return entityList;
        }

        /// <summary>
        /// 根据表达式筛选
        /// </summary>
        /// <typeparam name="TFirst"></typeparam>
        /// <typeparam name="TSecond"></typeparam>
        /// <typeparam name="TReturn"></typeparam>
        /// <param name="sql"></param>
        /// <param name="map"></param>
        /// <param name="param"></param>
        /// <param name="transaction"></param>
        /// <param name="buffered"></param>
        /// <param name="splitOn"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        public IEnumerable<TReturn> Get<TFirst, TSecond, TReturn>(string sql, Func<TFirst, TSecond, TReturn> map,
            dynamic param = null, IDbTransaction transaction = null, bool buffered = true, string splitOn = "Id",
            int? commandTimeout = null)
        {
            return DBSession.Connection.Query(sql, map, param as object, transaction, buffered, splitOn);
        }

        /// <summary>
        /// 根据表达式筛选
        /// </summary>
        /// <typeparam name="TFirst"></typeparam>
        /// <typeparam name="TSecond"></typeparam>
        /// <typeparam name="TReturn"></typeparam>
        /// <param name="sql"></param>
        /// <param name="map"></param>
        /// <param name="param"></param>
        /// <param name="transaction"></param>
        /// <param name="buffered"></param>
        /// <param name="splitOn"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        public IEnumerable<TReturn> Get<TFirst, TSecond, TThird, TReturn>(string sql, Func<TFirst, TSecond, TThird, TReturn> map,
            dynamic param = null, IDbTransaction transaction = null, bool buffered = true, string splitOn = "Id",
            int? commandTimeout = null)
        {
            return DBSession.Connection.Query(sql, map, param as object, transaction, buffered, splitOn);
        }

        /// <summary>
        /// 获取多实体集合
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <param name="commandType"></param>
        /// <returns></returns>
        public SqlMapper.GridReader GetMultiple(string sql, dynamic param = null, IDbTransaction transaction = null,
            int? commandTimeout = null, CommandType? commandType = null)
        {
            return DBSession.Connection.QueryMultiple(sql, param as object, transaction, commandTimeout, commandType);
        }

        /// <summary>
        /// 执行sql操作
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public int Execute(string sql, dynamic param = null, IDbTransaction transaction = null)
        {
            return DBSession.Connection.Execute(sql, param as object, transaction);
        }

    }
}

说起DapperExtensions修改的小地方还蛮多的，下图是一个代码比较的截图。所以一会把代码打包贴上来吧（见文章结尾）。

aaarticlea/png;base64,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" alt="" />

上述代码就可以编译成 HY.ORM.DLL文件了。

下面就可以在 自己业务层继承HY.ORM中的RepositoryServiceBase类   ，数据层继承HY.ORM中的 RepositoryBase类。

通过各自的构造函数或者， SetDBSession(Helper.CreateDBSession());  进行数据连接初始化。

接下来配置实体类和DB的映射：

    public class DemoEntity
    {
        public int ID { get; set; }

        public string Name { get; set; }
    }

    [Serializable]
    public class DomoEntityORMMapper : ClassMapper<DemoEntity>
    {
        public DomoEntityORMMapper()
        {
            base.Table("Demo");
            //Map(f => f.UserID).Ignore();//设置忽略
            //Map(f => f.Name).Key(KeyType.Identity);//设置主键  (如果主键名称不包含字母“ID”，请设置)
            AutoMap();
        }
    }

这样就可以在类中  实现   this.Get<DemoEntity>("select * from  Demo where ID=@ID", new { ID = 1 });   这样的语法了。

具体的使用方发

下图是我要介绍实现的项目截图：

aaarticlea/png;base64,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" alt="" />

其实也是三层，只是名字不一样而已。

HY.Web( UI层，MVC)

HY.Web.Iservice( 服务接口层)

HY.Web.Service（服务层，HY.Web.Iservice的实现类，    你也可以理解为业务逻辑层BLL）

HY.Web.DAO（数据访问层，   你也可以理解为DAL）

HY.Web.Entity(实体层，  目前只定义了数据实体， 如果你的系统需要给app提供数据， 那么传输的数据要精简，就需要单独定义DTO了。   )

就那用户表来做个实例吧，表结构如下：（下图是用代码生成器截图效果，可以直接修改数据库的描述信息，开发利器。需要的朋友点这里【CodeBuilder-RazorEngine】）

aaarticlea/png;base64,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" alt="" />

HY.Web.Entity

在HY.Web.Entity的项目中新建Sys_UsersEntity.cs  定义实体类

HY.Web.DAO

定义基类 BaseRepository.cs （可以设置默认的DBsession，方便扩展其它东东）

定义数据访问层 Sys_UsersRepository.cs （代码里可以封装任何需要写sql 的代码）

HY.Web.IService

定义接口 ISys_UsersService.cs ，提供给UI访问。

HY.Web.Service

定义BaseService.cs，（可以设置默认的DBsession，方便扩展其它东东）

定义Sys_UsersService.cs， 去实现ISys_UsersService。

HY.Web

1、定义相关的Controller

2、ISys_UsersService iSys_UsersService = new Sys_UsersService();  （这块其实可以使用 IoC， 相关内容且听后续分解）

3、调用接口

下载:

HY.DataAccess

修改后的DapperExtensions：Dapperextensions.RAR

ps:已经更新版本了，  加入了对lambda的扩展，点击这里进入

相关文章：

搭建一套自己实用的.net架构(1)【概述】

搭建一套自己实用的.net架构(2)【日志模块-log4net】

搭建一套自己实用的.net架构(3)【ORM-Dapper+DapperExtensions】

 搭建一套自己实用的.net架构(3)续 【ORM Dapper+DapperExtensions+Lambda】

搭建一套自己实用的.net架构(4)【CodeBuilder-RazorEngine】

原文链接：http://www.cnblogs.com/hy59005271/p/4759623.html