项目架构开发：数据访问层之Repository

接上文 项目架构开发：数据访问层之Logger

本章我们继续IRepository开发，这个仓储与领域模式里边的仓储有区别，更像一个工具类，也就是有些园友说的“伪仓储”，

这个仓储只实现单表的CURD与Query，都是通过主键ID或拉姆达表达式进行操作的，返回的都是单表的实体或实体集合，

多表的在IQuery接口中再讲；虽然如此，但是如果与“活动记录”开发模式搭配的话，会非常合适，可以减少开发的时间

及出错几率，更符合开发人员的类型调用习惯

IRepository.cs

     public interface IRepository<T> where T : class
     {
         void Add(T entity);
         void AddBatch(IEnumerable<T> entitys);
         void Update(T entity);
         void Delete(T entity);
         void Delete(string Id);
         void Delete(int Id);
         void Delete(Guid Id);
         T Get(string Id);
         T Get(Guid Id);
         T Get(int Id);
         T Get(T entity);
         T Get(Expression<Func<T, bool>> func);
         IEnumerable<T> GetAll();
         IEnumerable<T> GetList(Expression<Func<T, bool>> where = null, Expression<Func<T, bool>> order = null);
         Tuple<int, IEnumerable<T>> GetPage(Page page, Expression<Func<T, bool>> where = null, Expression<Func<T, bool>> order = null);
         long Count(Expression<Func<T, bool>> where = null);
     }

仓储的实现

这里我们只实现dapper的适配，EF有时间再搞吧

dapper大家应该都比较熟悉吧，不懂的朋友可以在园中搜索一下啊，很多案例

DapperRepository.cs

 using Dapper.Contrib.Extensions;
 using LjrFramework.Common;
 using LjrFramework.Interface;
 using System;
 using System.Collections.Generic;
 using System.Data;
 using System.Linq;
 using System.Linq.Expressions;

 namespace LjrFramework.Data.Dapper
 {
     public class DapperRepository<T> : IRepository<T> where T : class
     {
         protected IDbConnection Conn { get; private set; }

         public DapperRepository()
         {
             Conn = DbConnectionFactory.CreateDbConnection();
         }

         public void SetDbConnection(IDbConnection conn)
         {
             Conn = conn;
         }

         public void Add(T entity)
         {
             Conn.Insert<T>(entity);
         }

         public void AddBatch(IEnumerable<T> entitys)
         {
             foreach (T entity in entitys)
             {
                 Add(entity);
             }
         }

         public void Update(T entity)
         {
             Conn.Update(entity);
         }

         public void Delete(T entity)
         {
             Conn.Delete(entity);
         }

         public void Delete(string Id)
         {
             var entity = Get(Id);
             if (entity == null) return;

             Delete(entity);
         }

         public void Delete(int Id)
         {
             var entity = Get(Id);
             if (entity == null) return;

             Delete(entity);
         }
         public void Delete(Guid Id)
         {
             var entity = Get(Id);
             if (entity == null) return;

             Delete(entity);
         }

         public T Get(T entity)
         {
             return Conn.Get<T>(entity);
         }

         public T Get(Guid Id)
         {
             return Conn.Get<T>(Id);
         }

         public T Get(string Id)
         {
             return Conn.Get<T>(Id);
         }

         public T Get(int Id)
         {
             return Conn.Get<T>(Id);
         }

         public T Get(Expression<Func<T, bool>> func)
         {
             var linqToWhere = new LinqToWhere<T>();
             linqToWhere.Parse(func);

             return Conn.GetByFunc<T>(linqToWhere.Where, linqToWhere.KeyValuePairs);
         }

         public IEnumerable<T> GetAll()
         {
             return Conn.GetAll<T>();
         }

         public IEnumerable<T> GetList(Expression<Func<T, bool>> where = null, Expression<Func<T, bool>> order = null)
         {
             where = where.And(order);

             var linqToWhere = new LinqToWhere<T>();
             linqToWhere.Parse(where);

             return Conn.GetListByFunc<T>(linqToWhere.Where, linqToWhere.KeyValuePairs);
         }

         public Tuple<int, IEnumerable<T>> GetPage(Page page, Expression<Func<T, bool>> where = null, Expression<Func<T, bool>> order = null)
         {
             where = where.And(order);

             var linqToWhere = new LinqToWhere<T>();
             linqToWhere.Parse(where);

             var multi = Conn.GetPage<T>(page.PageIndex, page.PageSize, linqToWhere.Order, linqToWhere.Where, linqToWhere.KeyValuePairs);
             var count = multi.Read<int>().Single();
             var results = multi.Read<T>();

             return new Tuple<int, IEnumerable<T>>(count, results);
         }

         public long Count(Expression<Func<T, bool>> where = null)
         {
             var linqToWhere = new LinqToWhere<T>();
             linqToWhere.Parse(where);

             return Conn.Count<T>(linqToWhere.Where, linqToWhere.KeyValuePairs);
         }
     }
 }

注意标红的那行，Conn的所有方法都是在命名空间（Dapper.Contrib.Extensions）下的扩展方法

我们看看其中的Insert实现方式，为什么直接传递T就可以，而不用写sql语句

可以看到，dapper后台是遍历实体的属性，最后也是拼凑成符合格式的sql语句；

这一点也可以自己扩展，有很大的便利性，所以他写在Extensions中

DbConnectionFactory.cs 也很简单，是dapper支持多数据库的工厂类

 public class DbConnectionFactory
     {
         private static readonly string connectionString;
         private static readonly string databaseType;

         static DbConnectionFactory()
         {
             var collection = ConfigurationManager.ConnectionStrings["connectionString"];
             connectionString = collection.ConnectionString;
             databaseType = collection.ProviderName.ToLower();
         }

         public static IDbConnection CreateDbConnection()
         {
             IDbConnection connection = null;
             switch (databaseType)
             {
                 case "system.data.sqlclient":
                     connection = new System.Data.SqlClient.SqlConnection(connectionString);
                     break;
                 case "mysql":
                     //connection = new MySql.Data.MySqlClient.MySqlConnection(connectionString);
                     break;
                 case "oracle":
                     //connection = new Oracle.DataAccess.Client.OracleConnection(connectionString);
                     //connection = new System.Data.OracleClient.OracleConnection(connectionString);
                     break;
                 case "db2":
                     connection = new System.Data.OleDb.OleDbConnection(connectionString);
                     break;
                 default:
                     connection = new System.Data.SqlClient.SqlConnection(connectionString);
                     break;
             }
             return connection;
         }
     }

自此，dapper适配的仓储就完成了

我们在测试项目中看看效果，这里我们不在继续在基础设施里添加仓储了，用另一种方式：IOC

项目引用Autofac，用依赖出入来初始化IRepository<T>接口

测试仓储功能

 [TestClass]
     public class DapperRepositoryTest
     {
         private IRepository<LoginUser> repository;

         public DapperRepositoryTest()
         {
             var builder = new ContainerBuilder();
             builder.RegisterType<DapperRepository<LoginUser>>().As<IRepository<LoginUser>>();

             var container = builder.Build();
             repository = container.Resolve<IRepository<LoginUser>>();
         }

         [TestMethod]
         public void Add()
         {
             var loginUser = new LoginUser()
             {
                 Id = Guid.NewGuid(),
                 LoginName = "lanxiaoke-" + Guid.NewGuid().ToString(),
                 Password = "mima1987",
                 IsEnabled = ,
                 CreateTime = DateTime.Now
             };

             repository.Add(loginUser);

             long count = repository.Count(t => t.LoginName == loginUser.LoginName);

             Assert.AreEqual(true, count == );
         }

         [TestMethod]
         public void Get()
         {
             var loginUser = new LoginUser()
             {
                 Id = Guid.NewGuid(),
                 LoginName = "lanxiaoke-" + Guid.NewGuid().ToString(),
                 Password = "mima1987",
                 IsEnabled = ,
                 CreateTime = DateTime.Now
             };
             repository.Add(loginUser);

             var tmp = repository.Get(loginUser.Id);
             Assert.AreEqual(loginUser.Id, tmp.Id);

             var tmp2 = repository.Get(w => w.Id == loginUser.Id && w.IsEnabled == loginUser.IsEnabled);
             Assert.AreEqual(loginUser.Id, tmp2.Id);
         }
         ...//限于篇幅，只写这么多了，大部分代码都差不多
     }

注意这句：container.Resolve<IRepository<LoginUser>>(); 这句就是实现初始化IRepository<T>接口；

如何初始化呢？看上一句：builder.RegisterType<DapperRepository<LoginUser>>().As<IRepository<LoginUser>>(); 直接注册DapperRepository就可以了

其实这里也可以用配置的方式初始化IRepository<T>，这样就可以避免DapperRepository<T>与业务层耦合了

测试项目，我们就暂且这么写吧。

我们来看看效果

下边都是这次测试生成的数据

自此 IRepository 就开发完成了

项目架构开发系列

• 项目架构开发：数据访问层之Cache
• 项目架构开发：数据访问层之Logger
• 项目架构开发：数据访问层之Repository
• 项目架构开发：数据访问层之Query
• 项目架构开发：数据访问层之UnitOfWork