【无私分享：ASP.NET CORE 项目实战（第五章）】Repository仓储 UnitofWork

目录索引　

简介

　　本章我们来创建仓储类Repository 并且引入 UnitOfWork

我对UnitOfWork的一些理解

　　 UnitOfWork 工作单元，对于这个的解释和实例，网上很多很多大神之作，我在这就不班门弄斧了，只是浅谈一下个人理解，不一定对，希望大家指正：

　　UnitOfWork 看了很多，个人理解就是统一事务，在很多操作中我们可能是进行多项操作的，比如同时保存两个表的数据，如果我们先保存一个表（SaveChanges()之后），再保存另一个表（SaveChanges()）其实是两个不同的事务，通俗的讲，我们对数据库提交了两次数据。而UnitOfWork 就是把本次操作（分别保存两张表）放在统一事务中，所有的CRUD完成后，统一提交数据，即保证数据的一致性，又减少了提交次数，提高性能。

　　举个例子，我们之前的Repository的保存操作：

　　Repository:

　　public virtual bool Save(T entity)
　　{
　　　　_Context.Add(entity);
　　　　return _Context.SaveChanges() > 0;
　　}

　　Controller:

　　public ActionResult Save()

　　{

　　　　var Users=new Users(){Id=1,UserName="张三"};

　　　　var Logs=new Logs(){log="注册了用户张三"};

　　　　_UserService.Save(Users);

　　　　_LogService.Save(Logs);

　　}

因为本身EF就是带事务的，但是_Context.SaveChanges()之后，事务就结束了，也提交了数据。所以，上面的例子应该是开启了两次事务，提交了两次数据（一次是Users 一次是 Logs）

这显然是不合理的，首先不说提交两次数据性能的问题，如果用户注册失败，那么日志也不应该添加，应该回滚。但是，显然，上面没有这么做。

所以有了UnitOfWork。

使用UnitOfWork之后，代码应该是这样的：

　　UnitOfWork:

　　public bool Commit()
　　{
　　　　return _Context.SaveChanges() > 0;
　　}

　　Repository:

　　public virtual bool Save(T entity)
　　{
　　　　_Context.Add(entity);
　　}

　　Controller:

　　public ActionResult Save()

　　{

　　　　var Users=new Users(){Id=1,UserName="张三"};

　　　　var Logs=new Logs(){log="注册了用户张三"};

　　　　_UserService.Save(Users);

　　　　_LogService.Save(Logs);

　　　　_UnitOfWork.Commit();

　　}

UnitOfWork接口和实现类

我们在wkmvc.Core类库下，新建一个接口 IUnitOfWork：

 1 namespace wkmvc.Core
 2 {
 3     /// <summary>
 4     /// Describe：工作单元接口
 5     /// Author：yuangang
 6     /// Date：2016/07/16
 7     /// Blogs:http://www.cnblogs.com/yuangang
 8     /// </summary>
 9     public interface IUnitOfWork
10     {
11         bool Commit();
12     }
13 }

　　IUnitOfWork 实现类 UnitOfWork：

 1 using System;
 2 using wkmvc.Data;
 3 
 4 namespace wkmvc.Core
 5 {
 6     /// <summary>
 7     /// Describe：工作单元实现类
 8     /// Author：yuangang
 9     /// Date：2016/07/16
10     /// Blogs:http://www.cnblogs.com/yuangang
11     /// </summary>
12     public class UnitOfWork : IUnitOfWork, IDisposable
13     {
14         #region 数据上下文
15 
16         /// <summary>
17         /// 数据上下文
18         /// </summary>
19         private ApplicationDbContext _Context;
20         public UnitOfWork(ApplicationDbContext Context)
21         {
22             _Context = Context;
23         }
24 
25         #endregion
26 
27         public bool Commit()
28         {
29             return _Context.SaveChanges() > 0;
30         }
31 
32         public void Dispose()
33         {
34             if(_Context!=null)
35             {
36                 _Context.Dispose();
37             }
38             GC.SuppressFinalize(this);
39         }
40     }
41 }

　　这样，UnitOfWork 就完成了。下面我们来添加仓储：

仓储 IRepository、Repository

新建接口 IRepository 添加基本的操作方法：

 1 using System;
 2 using System.Linq.Expressions;
 3 
 4 namespace wkmvc.Core
 5 {
 6     /// <summary>
 7     /// Describe：仓储接口
 8     /// Author：yuangang
 9     /// Date：2016/07/16
10     /// Blogs:http://www.cnblogs.com/yuangang
11     /// </summary>
12     /// <typeparam name="T">实体模型</typeparam>
13     public interface IRepository<T> where T : class
14     {
15         #region 单模型 CRUD 操作
16 
17         /// <summary>
18         /// 增加一条记录
19         /// </summary>
20         /// <param name="entity">实体模型</param>
21         /// <param name="IsCommit">是否提交（默认提交）</param>
22         /// <returns></returns>
23         bool Save(T entity, bool IsCommit = true);
24 
25         /// <summary>
26         /// 更新一条记录
27         /// </summary>
28         /// <param name="entity">实体模型</param>
29         /// <param name="IsCommit">是否提交（默认提交）</param>
30         /// <returns></returns>
31         bool Update(T entity, bool IsCommit = true);
32 
33         /// <summary>
34         /// 增加或更新一条记录
35         /// </summary>
36         /// <param name="entity">实体模型</param>
37         /// <param name="IsSave">是否增加</param>
38         /// <param name="IsCommit">是否提交（默认提交）</param>
39         /// <returns></returns>
40         bool SaveOrUpdate(T entity, bool IsSave, bool IsCommit = true);
41 
42         /// <summary>
43         /// 通过Lamda表达式获取实体
44         /// </summary>
45         /// <param name="predicate">Lamda表达式（p=>p.Id==Id）</param>
46         /// <returns></returns>
47         T Get(Expression<Func<T, bool>> predicate);
48 
49         /// <summary>
50         /// 删除一条记录
51         /// </summary>
52         /// <param name="entity">实体模型</param>
53         /// <param name="IsCommit">是否提交（默认提交）</param>
54         /// <returns></returns>
55         bool Delete(T entity, bool IsCommit = true);
56 
57         #endregion
58     }
59 }

　　实现类 Repository :

  1 using Microsoft.EntityFrameworkCore;
  2 using System;
  3 using System.Linq;
  4 using System.Linq.Expressions;
  5 using wkmvc.Data;
  6 
  7 namespace wkmvc.Core
  8 {
  9     /// <summary>
 10     /// Describe：仓储实现类
 11     /// Author：yuangang
 12     /// Date：2016/07/16
 13     /// Blogs:http://www.cnblogs.com/yuangang
 14     /// </summary>
 15     /// <typeparam name="T">实体模型</typeparam>
 16     public abstract class Repository<T> : IRepository<T> where T : class
 17     {
 18         #region 数据上下文
 19 
 20         /// <summary>
 21         /// 数据上下文
 22         /// </summary>
 23         private ApplicationDbContext _Context;
 24 
 25         /// <summary>
 26         /// 工作单元
 27         /// </summary>
 28         UnitOfWork _UnitOfWork;
 29 
 30         public Repository(ApplicationDbContext Context)
 31         {
 32             _Context = Context;
 33             _UnitOfWork = new UnitOfWork(_Context);
 34         }
 35 
 36 
 37         #endregion
 38 
 39         #region 单模型 CRUD 操作
 40 
 41         /// <summary>
 42         /// 增加一条记录
 43         /// </summary>
 44         /// <param name="entity">实体模型</param>
 45         /// <param name="IsCommit">是否提交（默认提交）</param>
 46         /// <returns></returns>
 47         public virtual bool Save(T entity,bool IsCommit=true)
 48         {
 49             _Context.Add(entity);
 50             if (IsCommit)
 51                 return _UnitOfWork.Commit();
 52             else
 53                 return false;
 54         }
 55 
 56         /// <summary>
 57         /// 更新一条记录
 58         /// </summary>
 59         /// <param name="entity">实体模型</param>
 60         /// <param name="IsCommit">是否提交（默认提交）</param>
 61         /// <returns></returns>
 62         public virtual bool Update(T entity, bool IsCommit = true)
 63         {
 64             _Context.Attach(entity);
 65             _Context.Entry(entity).State = EntityState.Modified;
 66             if (IsCommit)
 67                 return _UnitOfWork.Commit();
 68             else
 69                 return false;
 70         }
 71 
 72         /// <summary>
 73         /// 增加或更新一条记录
 74         /// </summary>
 75         /// <param name="entity">实体模型</param>
 76         /// <param name="IsSave">是否增加</param>
 77         /// <param name="IsCommit">是否提交（默认提交）</param>
 78         /// <returns></returns>
 79         public virtual bool SaveOrUpdate(T entity, bool IsSave, bool IsCommit = true)
 80         {
 81             return IsSave ? Save(entity, IsCommit) : Update(entity, IsCommit);
 82         }
 83 
 84         /// <summary>
 85         /// 通过Lamda表达式获取实体
 86         /// </summary>
 87         /// <param name="predicate">Lamda表达式（p=>p.Id==Id）</param>
 88         /// <returns></returns>
 89         public virtual T Get(Expression<Func<T, bool>> predicate)
 90         {
 91             return _Context.Set<T>().AsNoTracking().SingleOrDefault(predicate);
 92         }
 93 
 94 
 95         /// <summary>
 96         /// 删除一条记录
 97         /// </summary>
 98         /// <param name="entity">实体模型</param>
 99         /// <param name="IsCommit">是否提交（默认提交）</param>
100         /// <returns></returns>
101         public virtual bool Delete(T entity, bool IsCommit = true)
102         {
103             if (entity == null) return false;
104             _Context.Remove(entity);
105 
106             if (IsCommit)
107                 return _UnitOfWork.Commit();
108             else
109                 return false;
110         }
111 
112         #endregion
113 
114 
115     }
116 }

我们都添加了一个 bool IsCommit = true 参数，是为了方便，如果仅仅是进行一项操作，那就没必要使用 UnitOfWork 统一直接 SaveChanages() 就行了

我们来看下使用：

　　//第一种
　　public bool TestOne()
　　{
　　　　var users = new SYS_USER() { UserName="张三",Account="zhangsan",Password="123456" };

　　　　return _UserService.Save(users);
　　}

　　//第二种
　　public bool TestTwo()
　　{
　　　　var users1 = new SYS_USER() { UserName = "张三", Account = "zhangsan", Password = "123456" };
　　　　var users2 = new SYS_USER() { UserName = "李四", Account = "lisi", Password = "456789" };
　　　　var users3 = new SYS_USER() { UserName = "王五", Account = "wangwu", Password = "321654" };

　　　　_UserService.Save(users1);
　　　　_UserService.Save(users2);
　　　　_UserService.Save(users3);

　　　　return _UnitOfWork.Commit();
　　}

本篇主要是介绍用法，具体的解释清大家参考大神们的讲解，如有不对的地方希望指正。具体的实现代码，我们后面一起一点一点写。

给大家贴一下个人实现的仓储 IRepository、Repository代码：

IRepository：

  1     public interface IRepository<T> where T : class
  2     {
  3         #region 单模型 CRUD 操作
  4 
  5         /// <summary>
  6         /// 增加一条记录
  7         /// </summary>
  8         /// <param name="entity">实体模型</param>
  9         /// <param name="IsCommit">是否提交（默认提交）</param>
 10         /// <returns></returns>
 11         bool Save(T entity, bool IsCommit = true);
 12         /// <summary>
 13         /// 增加一条记录（异步方式）
 14         /// </summary>
 15         /// <param name="entity">实体模型</param>
 16         /// <param name="IsCommit">是否提交（默认提交）</param>
 17         /// <returns></returns>
 18         Task<bool> SaveAsync(T entity, bool IsCommit = true);
 19 
 20         /// <summary>
 21         /// 更新一条记录
 22         /// </summary>
 23         /// <param name="entity">实体模型</param>
 24         /// <param name="IsCommit">是否提交（默认提交）</param>
 25         /// <returns></returns>
 26         bool Update(T entity, bool IsCommit = true);
 27         /// <summary>
 28         /// 更新一条记录（异步方式）
 29         /// </summary>
 30         /// <param name="entity">实体模型</param>
 31         /// <param name="IsCommit">是否提交（默认提交）</param>
 32         /// <returns></returns>
 33         Task<bool> UpdateAsync(T entity, bool IsCommit = true);
 34 
 35         /// <summary>
 36         /// 增加或更新一条记录
 37         /// </summary>
 38         /// <param name="entity">实体模型</param>
 39         /// <param name="IsSave">是否增加</param>
 40         /// <param name="IsCommit">是否提交（默认提交）</param>
 41         /// <returns></returns>
 42         bool SaveOrUpdate(T entity, bool IsSave, bool IsCommit = true);
 43         /// <summary>
 44         /// 增加或更新一条记录（异步方式）
 45         /// </summary>
 46         /// <param name="entity">实体模型</param>
 47         /// <param name="IsSave">是否增加</param>
 48         /// <param name="IsCommit">是否提交（默认提交）</param>
 49         /// <returns></returns>
 50         Task<bool> SaveOrUpdateAsync(T entity, bool IsSave, bool IsCommit = true);
 51 
 52         /// <summary>
 53         /// 通过Lamda表达式获取实体
 54         /// </summary>
 55         /// <param name="predicate">Lamda表达式（p=>p.Id==Id）</param>
 56         /// <returns></returns>
 57         T Get(Expression<Func<T, bool>> predicate);
 58         /// <summary>
 59         /// 通过Lamda表达式获取实体（异步方式）
 60         /// </summary>
 61         /// <param name="predicate">Lamda表达式（p=>p.Id==Id）</param>
 62         /// <returns></returns>
 63         Task<T> GetAsync(Expression<Func<T, bool>> predicate);
 64 
 65         /// <summary>
 66         /// 删除一条记录
 67         /// </summary>
 68         /// <param name="entity">实体模型</param>
 69         /// <param name="IsCommit">是否提交（默认提交）</param>
 70         /// <returns></returns>
 71         bool Delete(T entity, bool IsCommit = true);
 72         /// <summary>
 73         /// 删除一条记录（异步方式）
 74         /// </summary>
 75         /// <param name="entity">实体模型</param>
 76         /// <param name="IsCommit">是否提交（默认提交）</param>
 77         /// <returns></returns>
 78         Task<bool> DeleteAsync(T entity, bool IsCommit = true);
 79 
 80         #endregion
 81 
 82         #region 多模型 操作
 83 
 84         /// <summary>
 85         /// 增加多条记录，同一模型
 86         /// </summary>
 87         /// <param name="T1">实体模型集合</param>
 88         /// <param name="IsCommit">是否提交（默认提交）</param>
 89         /// <returns></returns>
 90         bool SaveList(List<T> T1, bool IsCommit = true);
 91         /// <summary>
 92         /// 增加多条记录，同一模型（异步方式）
 93         /// </summary>
 94         /// <param name="T1">实体模型集合</param>
 95         /// <param name="IsCommit">是否提交（默认提交）</param>
 96         /// <returns></returns>
 97         Task<bool> SaveListAsync(List<T> T1, bool IsCommit = true);
 98 
 99         /// <summary>
100         /// 增加多条记录，独立模型
101         /// </summary>
102         /// <param name="T1">实体模型集合</param>
103         /// <param name="IsCommit">是否提交（默认提交）</param>
104         /// <returns></returns>
105         bool SaveList<T1>(List<T1> T, bool IsCommit = true) where T1 : class;
106         /// <summary>
107         /// 增加多条记录，独立模型（异步方式）
108         /// </summary>
109         /// <param name="T1">实体模型集合</param>
110         /// <param name="IsCommit">是否提交（默认提交）</param>
111         /// <returns></returns>
112         Task<bool> SaveListAsync<T1>(List<T1> T, bool IsCommit = true) where T1 : class;
113 
114         /// <summary>
115         /// 更新多条记录，同一模型
116         /// </summary>
117         /// <param name="T1">实体模型集合</param>
118         /// <param name="IsCommit">是否提交（默认提交）</param>
119         /// <returns></returns>
120         bool UpdateList(List<T> T1, bool IsCommit = true);
121         /// <summary>
122         /// 更新多条记录，同一模型（异步方式）
123         /// </summary>
124         /// <param name="T1">实体模型集合</param>
125         /// <param name="IsCommit">是否提交（默认提交）</param>
126         /// <returns></returns>
127         Task<bool> UpdateListAsync(List<T> T1, bool IsCommit = true);
128 
129         /// <summary>
130         /// 更新多条记录，独立模型
131         /// </summary>
132         /// <param name="T1">实体模型集合</param>
133         /// <param name="IsCommit">是否提交（默认提交）</param>
134         /// <returns></returns>
135         bool UpdateList<T1>(List<T1> T, bool IsCommit = true) where T1 : class;
136         /// <summary>
137         /// 更新多条记录，独立模型（异步方式）
138         /// </summary>
139         /// <param name="T1">实体模型集合</param>
140         /// <param name="IsCommit">是否提交（默认提交）</param>
141         /// <returns></returns>
142         Task<bool> UpdateListAsync<T1>(List<T1> T, bool IsCommit = true) where T1 : class;
143 
144         /// <summary>
145         /// 删除多条记录，同一模型
146         /// </summary>
147         /// <param name="T1">实体模型集合</param>
148         /// <param name="IsCommit">是否提交（默认提交）</param>
149         /// <returns></returns>
150         bool DeleteList(List<T> T1, bool IsCommit = true);
151         /// <summary>
152         /// 删除多条记录，同一模型（异步方式）
153         /// </summary>
154         /// <param name="T1">实体模型集合</param>
155         /// <param name="IsCommit">是否提交（默认提交）</param>
156         /// <returns></returns>
157         Task<bool> DeleteListAsync(List<T> T1, bool IsCommit = true);
158 
159         /// <summary>
160         /// 删除多条记录，独立模型
161         /// </summary>
162         /// <param name="T1">实体模型集合</param>
163         /// <param name="IsCommit">是否提交（默认提交）</param>
164         /// <returns></returns>
165         bool DeleteList<T1>(List<T1> T, bool IsCommit = true) where T1 : class;
166         /// <summary>
167         /// 删除多条记录，独立模型（异步方式）
168         /// </summary>
169         /// <param name="T1">实体模型集合</param>
170         /// <param name="IsCommit">是否提交（默认提交）</param>
171         /// <returns></returns>
172         Task<bool> DeleteListAsync<T1>(List<T1> T, bool IsCommit = true) where T1 : class;
173 
174         /// <summary>
175         /// 通过Lamda表达式，删除一条或多条记录
176         /// </summary>
177         /// <param name="predicate"></param>
178         /// <param name="IsCommit"></param>
179         /// <returns></returns>
180         bool Delete(Expression<Func<T, bool>> predicate, bool IsCommit = true);
181         /// <summary>
182         /// 通过Lamda表达式，删除一条或多条记录（异步方式）
183         /// </summary>
184         /// <param name="predicate"></param>
185         /// <param name="IsCommit"></param>
186         /// <returns></returns>
187         Task<bool> DeleteAsync(Expression<Func<T, bool>> predicate, bool IsCommit = true);
188 
189         #endregion
190 
191         #region 获取多条数据操作
192 
193         /// <summary>
194         /// 返回IQueryable集合，延时加载数据
195         /// </summary>
196         /// <param name="predicate"></param>
197         /// <returns></returns>
198         IQueryable<T> LoadAll(Expression<Func<T, bool>> predicate);
199         /// <summary>
200         /// 返回IQueryable集合，延时加载数据（异步方式）
201         /// </summary>
202         /// <param name="predicate"></param>
203         /// <returns></returns>
204         Task<IQueryable<T>> LoadAllAsync(Expression<Func<T, bool>> predicate);
205 
206         // <summary>
207         /// 返回List<T>集合,不采用延时加载
208         /// </summary>
209         /// <param name="predicate"></param>
210         /// <returns></returns>
211         List<T> LoadListAll(Expression<Func<T, bool>> predicate);
212         // <summary>
213         /// 返回List<T>集合,不采用延时加载（异步方式）
214         /// </summary>
215         /// <param name="predicate"></param>
216         /// <returns></returns>
217         Task<List<T>> LoadListAllAsync(Expression<Func<T, bool>> predicate);
218 
219         /// <summary>
220         /// T-Sql方式：返回IQueryable<T>集合
221         /// </summary>
222         /// <param name="sql">SQL语句</param>
223         /// <param name="para">Parameters参数</param>
224         /// <returns></returns>
225         IQueryable<T> LoadAllBySql(string sql, params DbParameter[] para);
226         /// <summary>
227         /// T-Sql方式：返回IQueryable<T>集合（异步方式）
228         /// </summary>
229         /// <param name="sql">SQL语句</param>
230         /// <param name="para">Parameters参数</param>
231         /// <returns></returns>
232         Task<IQueryable<T>> LoadAllBySqlAsync(string sql, params DbParameter[] para);
233 
234         /// <summary>
235         /// T-Sql方式：返回List<T>集合
236         /// </summary>
237         /// <param name="sql">SQL语句</param>
238         /// <param name="para">Parameters参数</param>
239         /// <returns></returns>
240         List<T> LoadListAllBySql(string sql, params DbParameter[] para);
241         /// <summary>
242         /// T-Sql方式：返回List<T>集合（异步方式）
243         /// </summary>
244         /// <param name="sql">SQL语句</param>
245         /// <param name="para">Parameters参数</param>
246         /// <returns></returns>
247         Task<List<T>> LoadListAllBySqlAsync(string sql, params DbParameter[] para);
248 
249         /// <summary>
250         /// 可指定返回结果、排序、查询条件的通用查询方法，返回实体对象集合
251         /// </summary>
252         /// <typeparam name="TEntity">实体对象</typeparam>
253         /// <typeparam name="TOrderBy">排序字段类型</typeparam>
254         /// <typeparam name="TResult">数据结果，与TEntity一致</typeparam>
255         /// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
256         /// <param name="orderby">排序字段</param>
257         /// <param name="selector">返回结果（必须是模型中存在的字段）</param>
258         /// <param name="IsAsc">排序方向，true为正序false为倒序</param>
259         /// <returns>实体集合</returns>
260         List<TResult> QueryEntity<TEntity, TOrderBy, TResult>(Expression<Func<TEntity, bool>> where,Expression<Func<TEntity, TOrderBy>> orderby,Expression<Func<TEntity, TResult>> selector,bool IsAsc)
261             where TEntity : class
262             where TResult : class;
263         /// <summary>
264         /// 可指定返回结果、排序、查询条件的通用查询方法，返回实体对象集合（异步方式）
265         /// </summary>
266         /// <typeparam name="TEntity">实体对象</typeparam>
267         /// <typeparam name="TOrderBy">排序字段类型</typeparam>
268         /// <typeparam name="TResult">数据结果，与TEntity一致</typeparam>
269         /// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
270         /// <param name="orderby">排序字段</param>
271         /// <param name="selector">返回结果（必须是模型中存在的字段）</param>
272         /// <param name="IsAsc">排序方向，true为正序false为倒序</param>
273         /// <returns>实体集合</returns>
274         Task<List<TResult>> QueryEntityAsync<TEntity, TOrderBy, TResult>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Expression<Func<TEntity, TResult>> selector, bool IsAsc)
275             where TEntity : class
276             where TResult : class;
277 
278         /// <summary>
279         /// 可指定返回结果、排序、查询条件的通用查询方法，返回Object对象集合
280         /// </summary>
281         /// <typeparam name="TEntity">实体对象</typeparam>
282         /// <typeparam name="TOrderBy">排序字段类型</typeparam>
283         /// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
284         /// <param name="orderby">排序字段</param>
285         /// <param name="selector">返回结果（必须是模型中存在的字段）</param>
286         /// <param name="IsAsc">排序方向，true为正序false为倒序</param>
287         /// <returns>自定义实体集合</returns>
288         List<object> QueryObject<TEntity, TOrderBy>(Expression<Func<TEntity, bool>> where,Expression<Func<TEntity, TOrderBy>> orderby,Func<IQueryable<TEntity>,List<object>> selector,bool IsAsc)
289             where TEntity : class;
290         /// <summary>
291         /// 可指定返回结果、排序、查询条件的通用查询方法，返回Object对象集合（异步方式）
292         /// </summary>
293         /// <typeparam name="TEntity">实体对象</typeparam>
294         /// <typeparam name="TOrderBy">排序字段类型</typeparam>
295         /// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
296         /// <param name="orderby">排序字段</param>
297         /// <param name="selector">返回结果（必须是模型中存在的字段）</param>
298         /// <param name="IsAsc">排序方向，true为正序false为倒序</param>
299         /// <returns>自定义实体集合</returns>
300         Task<List<object>> QueryObjectAsync<TEntity, TOrderBy>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Func<IQueryable<TEntity>, List<object>> selector, bool IsAsc)
301             where TEntity : class;
302 
303         /// <summary>
304         /// 可指定返回结果、排序、查询条件的通用查询方法，返回动态类对象集合
305         /// </summary>
306         /// <typeparam name="TEntity">实体对象</typeparam>
307         /// <typeparam name="TOrderBy">排序字段类型</typeparam>
308         /// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
309         /// <param name="orderby">排序字段</param>
310         /// <param name="selector">返回结果（必须是模型中存在的字段）</param>
311         /// <param name="IsAsc">排序方向，true为正序false为倒序</param>
312         /// <returns>动态类</returns>
313         dynamic QueryDynamic<TEntity, TOrderBy>(Expression<Func<TEntity, bool>> where,Expression<Func<TEntity, TOrderBy>> orderby, Func<IQueryable<TEntity>,List<object>> selector,bool IsAsc)
314             where TEntity : class;
315         /// <summary>
316         /// 可指定返回结果、排序、查询条件的通用查询方法，返回动态类对象集合（异步方式）
317         /// </summary>
318         /// <typeparam name="TEntity">实体对象</typeparam>
319         /// <typeparam name="TOrderBy">排序字段类型</typeparam>
320         /// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
321         /// <param name="orderby">排序字段</param>
322         /// <param name="selector">返回结果（必须是模型中存在的字段）</param>
323         /// <param name="IsAsc">排序方向，true为正序false为倒序</param>
324         /// <returns>动态类</returns>
325         Task<dynamic> QueryDynamicAsync<TEntity, TOrderBy>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Func<IQueryable<TEntity>, List<object>> selector, bool IsAsc)
326             where TEntity : class;
327 
328         #endregion
329 
330         #region 验证是否存在
331 
332         /// <summary>
333         /// 验证当前条件是否存在相同项
334         /// </summary>
335         bool IsExist(Expression<Func<T, bool>> predicate);
336         /// <summary>
337         /// 验证当前条件是否存在相同项（异步方式）
338         /// </summary>
339         Task<bool> IsExistAsync(Expression<Func<T, bool>> predicate);
340 
341         /// <summary>
342         /// 根据SQL验证实体对象是否存在
343         /// </summary>
344         bool IsExist(string sql, params DbParameter[] para);
345         /// <summary>
346         /// 根据SQL验证实体对象是否存在（异步方式）
347         /// </summary>
348         Task<bool> IsExistAsync(string sql, params DbParameter[] para);
349 
350         #endregion
351     }

View Code