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

时间：2017-02-19 15:23:32 阅读：3689 评论：0 收藏：0 [点我收藏+]

标签：应该 username syntax ext man cte ini 实例 csharp

目录索引　

简介

　　本章我们来创建仓储类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

Repository：

  1   public abstract class Repository<T> : IRepository<T> where T : class
  2     {
  3         #region 数据上下文
  4 
  5         /// <summary>
  6         /// 数据上下文
  7         /// </summary>
  8         private ApplicationDbContext _Context;       
  9 
 10         public Repository(ApplicationDbContext Context)
 11         {
 12             _Context = Context;
 13         }
 14 
 15         #endregion
 16 
 17         #region 单模型 CRUD 操作
 18 
 19         /// <summary>
 20         /// 增加一条记录
 21         /// </summary>
 22         /// <param name="entity">实体模型</param>
 23         /// <param name="IsCommit">是否提交（默认提交）</param>
 24         /// <returns></returns>
 25         public virtual bool Save(T entity,bool IsCommit=true)
 26         {
 27             _Context.Set<T>().Add(entity);
 28             if (IsCommit)
 29                 return _Context.SaveChanges() > 0;
 30             else
 31                 return false;
 32         }
 33         /// <summary>
 34         /// 增加一条记录(异步方式)
 35         /// </summary>
 36         /// <param name="entity">实体模型</param>
 37         /// <param name="IsCommit">是否提交（默认提交）</param>
 38         /// <returns></returns>
 39         public virtual async Task<bool> SaveAsync(T entity, bool IsCommit = true)
 40         {
 41             _Context.Set<T>().Add(entity);
 42             if (IsCommit)
 43                 return await Task.Run(() => _Context.SaveChanges() > 0);
 44             else
 45                 return await Task.Run(() => false); 
 46         }
 47 
 48         /// <summary>
 49         /// 更新一条记录
 50         /// </summary>
 51         /// <param name="entity">实体模型</param>
 52         /// <param name="IsCommit">是否提交（默认提交）</param>
 53         /// <returns></returns>
 54         public virtual bool Update(T entity, bool IsCommit = true)
 55         {
 56             _Context.Set<T>().Attach(entity);
 57             _Context.Entry<T>(entity).State = EntityState.Modified;
 58             if (IsCommit)
 59                 return _Context.SaveChanges() > 0;
 60             else
 61                 return false;
 62         }
 63         /// <summary>
 64         /// 更新一条记录（异步方式）
 65         /// </summary>
 66         /// <param name="entity">实体模型</param>
 67         /// <param name="IsCommit">是否提交（默认提交）</param>
 68         /// <returns></returns>
 69         public virtual async Task<bool> UpdateAsync(T entity, bool IsCommit = true)
 70         {
 71             _Context.Set<T>().Attach(entity);
 72             _Context.Entry<T>(entity).State = EntityState.Modified;
 73             if (IsCommit)
 74                 return await Task.Run(() => _Context.SaveChanges() > 0);
 75             else
 76                 return await Task.Run(() => false);
 77         }
 78 
 79         /// <summary>
 80         /// 增加或更新一条记录
 81         /// </summary>
 82         /// <param name="entity">实体模型</param>
 83         /// <param name="IsSave">是否增加</param>
 84         /// <param name="IsCommit">是否提交（默认提交）</param>
 85         /// <returns></returns>
 86         public virtual bool SaveOrUpdate(T entity, bool IsSave, bool IsCommit = true)
 87         {
 88             return IsSave ? Save(entity, IsCommit) : Update(entity, IsCommit);
 89         }
 90         /// <summary>
 91         /// 增加或更新一条记录（异步方式）
 92         /// </summary>
 93         /// <param name="entity">实体模型</param>
 94         /// <param name="IsSave">是否增加</param>
 95         /// <param name="IsCommit">是否提交（默认提交）</param>
 96         /// <returns></returns>
 97         public virtual async Task<bool> SaveOrUpdateAsync(T entity, bool IsSave, bool IsCommit = true)
 98         {
 99             return IsSave ? await SaveAsync(entity, IsCommit) : await UpdateAsync(entity, IsCommit);
100         }
101 
102         /// <summary>
103         /// 通过Lamda表达式获取实体
104         /// </summary>
105         /// <param name="predicate">Lamda表达式（p=>p.Id==Id）</param>
106         /// <returns></returns>
107         public virtual T Get(Expression<Func<T, bool>> predicate)
108         {
109             return _Context.Set<T>().AsNoTracking().SingleOrDefault(predicate);
110         }
111         /// <summary>
112         /// 通过Lamda表达式获取实体（异步方式）
113         /// </summary>
114         /// <param name="predicate">Lamda表达式（p=>p.Id==Id）</param>
115         /// <returns></returns>
116         public virtual async Task<T> GetAsync(Expression<Func<T, bool>> predicate)
117         {
118             return await Task.Run(()=> _Context.Set<T>().AsNoTracking().SingleOrDefault(predicate));
119         }
120 
121         /// <summary>
122         /// 删除一条记录
123         /// </summary>
124         /// <param name="entity">实体模型</param>
125         /// <param name="IsCommit">是否提交（默认提交）</param>
126         /// <returns></returns>
127         public virtual bool Delete(T entity, bool IsCommit = true)
128         {
129             if (entity == null) return false;
130             _Context.Set<T>().Attach(entity);
131             _Context.Set<T>().Remove(entity);
132 
133             if (IsCommit)
134                 return _Context.SaveChanges() > 0;
135             else
136                 return false;
137         }
138         /// <summary>
139         /// 删除一条记录（异步方式）
140         /// </summary>
141         /// <param name="entity">实体模型</param>
142         /// <param name="IsCommit">是否提交（默认提交）</param>
143         /// <returns></returns>
144         public virtual async Task<bool> DeleteAsync(T entity, bool IsCommit = true)
145         {
146             if (entity == null) return await Task.Run(() => false);
147             _Context.Set<T>().Attach(entity);
148             _Context.Set<T>().Remove(entity);
149             if (IsCommit)
150                 return  await Task.Run(() => _Context.SaveChanges() > 0);
151             else
152                 return await Task.Run(() => false); ;
153         }
154 
155         #endregion
156 
157         #region 多模型 操作
158 
159         /// <summary>
160         /// 增加多条记录，同一模型
161         /// </summary>
162         /// <param name="T1">实体模型集合</param>
163         /// <param name="IsCommit">是否提交（默认提交）</param>
164         /// <returns></returns>
165         public virtual bool SaveList(List<T> T1, bool IsCommit = true) 
166         {
167             if (T1 == null || T1.Count == 0) return false;
168 
169             T1.ToList().ForEach(item =>
170             {
171                 _Context.Set<T>().Add(item);
172             });
173 
174             if (IsCommit)
175                 return _Context.SaveChanges() > 0;
176             else
177                 return false;
178         }
179         /// <summary>
180         /// 增加多条记录，同一模型（异步方式）
181         /// </summary>
182         /// <param name="T1">实体模型集合</param>
183         /// <param name="IsCommit">是否提交（默认提交）</param>
184         /// <returns></returns>
185         public virtual async Task<bool> SaveListAsync(List<T> T1, bool IsCommit = true)
186         {
187             if (T1 == null || T1.Count == 0) return await Task.Run(() => false);
188 
189             T1.ToList().ForEach(item =>
190             {
191                 _Context.Set<T>().Add(item);
192             });
193 
194             if (IsCommit)
195                 return await Task.Run(() => _Context.SaveChanges() > 0);
196             else
197                 return await Task.Run(() => false);
198         }
199 
200         /// <summary>
201         /// 增加多条记录，独立模型
202         /// </summary>
203         /// <param name="T1">实体模型集合</param>
204         /// <param name="IsCommit">是否提交（默认提交）</param>
205         /// <returns></returns>
206         public virtual bool SaveList<T1>(List<T1> T, bool IsCommit = true) where T1 : class
207         {
208             if (T == null || T.Count == 0) return false;
209             var tmp = _Context.ChangeTracker.Entries<T>().ToList();
210             foreach (var x in tmp)
211             {
212                 var properties = typeof(T).GetTypeInfo().GetProperties();
213                 foreach (var y in properties)
214                 {
215                     var entry = x.Property(y.Name);
216                     entry.CurrentValue = entry.OriginalValue;
217                     entry.IsModified = false;
218                     y.SetValue(x.Entity, entry.OriginalValue);
219                 }
220                 x.State = EntityState.Unchanged;
221             }
222             T.ToList().ForEach(item =>
223             {
224                 _Context.Set<T1>().Add(item);
225             });
226             if (IsCommit)
227                 return _Context.SaveChanges() > 0;
228             else
229                 return false;
230         }
231         /// <summary>
232         /// 增加多条记录，独立模型（异步方式）
233         /// </summary>
234         /// <param name="T1">实体模型集合</param>
235         /// <param name="IsCommit">是否提交（默认提交）</param>
236         /// <returns></returns>
237         public virtual async Task<bool> SaveListAsync<T1>(List<T1> T, bool IsCommit = true) where T1 : class
238         {
239             if (T == null || T.Count == 0) return await Task.Run(() => false);
240             var tmp = _Context.ChangeTracker.Entries<T>().ToList();
241             foreach (var x in tmp)
242             {
243                 var properties = typeof(T).GetTypeInfo().GetProperties();
244                 foreach (var y in properties)
245                 {
246                     var entry = x.Property(y.Name);
247                     entry.CurrentValue = entry.OriginalValue;
248                     entry.IsModified = false;
249                     y.SetValue(x.Entity, entry.OriginalValue);
250                 }
251                 x.State = EntityState.Unchanged;
252             }
253             T.ToList().ForEach(item =>
254             {
255                 _Context.Set<T1>().Add(item);
256             });
257             if (IsCommit)
258                 return await Task.Run(() => _Context.SaveChanges() > 0);
259             else
260                 return await Task.Run(() => false);
261         }
262 
263         /// <summary>
264         /// 更新多条记录，同一模型
265         /// </summary>
266         /// <param name="T1">实体模型集合</param>
267         /// <param name="IsCommit">是否提交（默认提交）</param>
268         /// <returns></returns>
269         public virtual bool UpdateList(List<T> T1, bool IsCommit = true)
270         {
271             if (T1 == null || T1.Count == 0) return false;
272 
273             T1.ToList().ForEach(item =>
274             {
275                 _Context.Set<T>().Attach(item);
276                 _Context.Entry<T>(item).State = EntityState.Modified;
277             });
278 
279             if (IsCommit)
280                 return _Context.SaveChanges() > 0;
281             else
282                 return false;
283         }
284         /// <summary>
285         /// 更新多条记录，同一模型（异步方式）
286         /// </summary>
287         /// <param name="T1">实体模型集合</param>
288         /// <param name="IsCommit">是否提交（默认提交）</param>
289         /// <returns></returns>
290         public virtual async Task<bool> UpdateListAsync(List<T> T1, bool IsCommit = true)
291         {
292             if (T1 == null || T1.Count == 0) return await Task.Run(() => false);
293 
294             T1.ToList().ForEach(item =>
295             {
296                 _Context.Set<T>().Attach(item);
297                 _Context.Entry<T>(item).State = EntityState.Modified;
298             });
299 
300             if (IsCommit)
301                 return await Task.Run(() => _Context.SaveChanges() > 0);
302             else
303                 return await Task.Run(() => false);
304         }
305 
306         /// <summary>
307         /// 更新多条记录，独立模型
308         /// </summary>
309         /// <param name="T1">实体模型集合</param>
310         /// <param name="IsCommit">是否提交（默认提交）</param>
311         /// <returns></returns>
312         public virtual bool UpdateList<T1>(List<T1> T, bool IsCommit = true) where T1 : class
313         {
314             if (T == null || T.Count == 0) return false;
315 
316             T.ToList().ForEach(item =>
317             {
318                 _Context.Set<T1>().Attach(item);
319                 _Context.Entry<T1>(item).State = EntityState.Modified;
320             });
321 
322             if (IsCommit)
323                 return _Context.SaveChanges() > 0;
324             else
325                 return false;
326         }
327         /// <summary>
328         /// 更新多条记录，独立模型（异步方式）
329         /// </summary>
330         /// <param name="T1">实体模型集合</param>
331         /// <param name="IsCommit">是否提交（默认提交）</param>
332         /// <returns></returns>
333         public virtual async Task<bool> UpdateListAsync<T1>(List<T1> T, bool IsCommit = true) where T1 : class
334         {
335             if (T == null || T.Count == 0) return await Task.Run(() => false);
336 
337             T.ToList().ForEach(item =>
338             {
339                 _Context.Set<T1>().Attach(item);
340                 _Context.Entry<T1>(item).State = EntityState.Modified;
341             });
342 
343             if (IsCommit)
344                 return await Task.Run(() => _Context.SaveChanges() > 0);
345             else
346                 return await Task.Run(() => false);
347         }
348 
349         /// <summary>
350         /// 删除多条记录，同一模型
351         /// </summary>
352         /// <param name="T1">实体模型集合</param>
353         /// <param name="IsCommit">是否提交（默认提交）</param>
354         /// <returns></returns>
355         public virtual bool DeleteList(List<T> T1, bool IsCommit = true)
356         {
357             if (T1 == null || T1.Count == 0) return false;
358 
359             T1.ToList().ForEach(item =>
360             {
361                 _Context.Set<T>().Attach(item);
362                 _Context.Set<T>().Remove(item);
363             });
364 
365             if (IsCommit)
366                 return _Context.SaveChanges() > 0;
367             else
368                 return false;
369         }
370         /// <summary>
371         /// 删除多条记录，同一模型（异步方式）
372         /// </summary>
373         /// <param name="T1">实体模型集合</param>
374         /// <param name="IsCommit">是否提交（默认提交）</param>
375         /// <returns></returns>
376         public virtual async Task<bool> DeleteListAsync(List<T> T1, bool IsCommit = true)
377         {
378             if (T1 == null || T1.Count == 0) return await Task.Run(() => false);
379 
380             T1.ToList().ForEach(item =>
381             {
382                 _Context.Set<T>().Attach(item);
383                 _Context.Set<T>().Remove(item);
384             });
385 
386             if (IsCommit)
387                 return await Task.Run(() => _Context.SaveChanges() > 0);
388             else
389                 return await Task.Run(() => false);
390         }
391 
392         /// <summary>
393         /// 删除多条记录，独立模型
394         /// </summary>
395         /// <param name="T1">实体模型集合</param>
396         /// <param name="IsCommit">是否提交（默认提交）</param>
397         /// <returns></returns>
398         public virtual bool DeleteList<T1>(List<T1> T, bool IsCommit = true) where T1 : class
399         {
400             if (T == null || T.Count == 0) return false;
401 
402             T.ToList().ForEach(item =>
403             {
404                 _Context.Set<T1>().Attach(item);
405                 _Context.Set<T1>().Remove(item);
406             });
407 
408             if (IsCommit)
409                 return _Context.SaveChanges() > 0;
410             else
411                 return false;
412         }
413         /// <summary>
414         /// 删除多条记录，独立模型（异步方式）
415         /// </summary>
416         /// <param name="T1">实体模型集合</param>
417         /// <param name="IsCommit">是否提交（默认提交）</param>
418         /// <returns></returns>
419         public virtual async Task<bool> DeleteListAsync<T1>(List<T1> T, bool IsCommit = true) where T1 : class
420         {
421             if (T == null || T.Count == 0) return await Task.Run(() => false);
422 
423             T.ToList().ForEach(item =>
424             {
425                 _Context.Set<T1>().Attach(item);
426                 _Context.Set<T1>().Remove(item);
427             });
428 
429             if (IsCommit)
430                 return await Task.Run(() => _Context.SaveChanges() > 0);
431             else
432                 return await Task.Run(() => false);
433         }
434 
435         /// <summary>
436         /// 通过Lamda表达式，删除一条或多条记录
437         /// </summary>
438         /// <param name="predicate"></param>
439         /// <param name="IsCommit"></param>
440         /// <returns></returns>
441         public virtual bool Delete(Expression<Func<T, bool>> predicate, bool IsCommit = true)
442         {
443             IQueryable<T> entry = (predicate == null) ? _Context.Set<T>().AsQueryable() : _Context.Set<T>().Where(predicate);
444             List<T> list = entry.ToList();
445 
446             if (list != null && list.Count == 0) return false;
447             list.ForEach(item => {
448                 _Context.Set<T>().Attach(item);
449                 _Context.Set<T>().Remove(item);
450             });
451 
452             if (IsCommit)
453                 return _Context.SaveChanges() > 0;
454             else
455                 return false;
456         }
457         /// <summary>
458         /// 通过Lamda表达式，删除一条或多条记录（异步方式）
459         /// </summary>
460         /// <param name="predicate"></param>
461         /// <param name="IsCommit"></param>
462         /// <returns></returns>
463         public virtual async Task<bool> DeleteAsync(Expression<Func<T, bool>> predicate, bool IsCommit = true)
464         {
465             IQueryable<T> entry = (predicate == null) ? _Context.Set<T>().AsQueryable() : _Context.Set<T>().Where(predicate);
466             List<T> list = entry.ToList();
467 
468             if (list != null && list.Count == 0) return await Task.Run(() => false);
469             list.ForEach(item => {
470                 _Context.Set<T>().Attach(item);
471                 _Context.Set<T>().Remove(item);
472             });
473 
474             if (IsCommit)
475                 return await Task.Run(() => _Context.SaveChanges() > 0);
476             else
477                 return await Task.Run(() => false);
478         }
479 
480         #endregion
481 
482         #region 获取多条数据操作
483 
484         /// <summary>
485         /// Lamda返回IQueryable集合，延时加载数据
486         /// </summary>
487         /// <param name="predicate"></param>
488         /// <returns></returns>
489         public virtual IQueryable<T> LoadAll(Expression<Func<T, bool>> predicate)
490         {
491             return predicate != null ? _Context.Set<T>().Where(predicate).AsNoTracking<T>() : _Context.Set<T>().AsQueryable<T>().AsNoTracking<T>();            
492         }
493         /// <summary>
494         /// 返回IQueryable集合，延时加载数据（异步方式）
495         /// </summary>
496         /// <param name="predicate"></param>
497         /// <returns></returns>
498         public virtual async Task<IQueryable<T>> LoadAllAsync(Expression<Func<T, bool>> predicate)
499         {
500             return predicate != null ? await Task.Run(()=> _Context.Set<T>().Where(predicate).AsNoTracking<T>()) : await Task.Run(() => _Context.Set<T>().AsQueryable<T>().AsNoTracking<T>());
501         }
502 
503         /// <summary>
504         /// 返回List<T>集合,不采用延时加载
505         /// </summary>
506         /// <param name="predicate"></param>
507         /// <returns></returns>
508         public virtual List<T> LoadListAll(Expression<Func<T, bool>> predicate)
509         {
510             return predicate != null ? _Context.Set<T>().Where(predicate).AsNoTracking().ToList() : _Context.Set<T>().AsQueryable<T>().AsNoTracking().ToList();
511         }
512         // <summary>
513         /// 返回List<T>集合,不采用延时加载（异步方式）
514         /// </summary>
515         /// <param name="predicate"></param>
516         /// <returns></returns>
517         public virtual async Task<List<T>> LoadListAllAsync(Expression<Func<T, bool>> predicate)
518         {
519             return predicate != null ? await Task.Run(() => _Context.Set<T>().Where(predicate).AsNoTracking().ToList()) : await Task.Run(() => _Context.Set<T>().AsQueryable<T>().AsNoTracking().ToList());
520         }
521 
522         /// <summary>
523         /// T-Sql方式：返回IQueryable<T>集合
524         /// </summary>
525         /// <param name="sql">SQL语句</param>
526         /// <param name="para">Parameters参数</param>
527         /// <returns></returns>
528         public virtual IQueryable<T> LoadAllBySql(string sql, params DbParameter[] para)
529         {
530             return _Context.Set<T>().FromSql(sql, para);
531         }
532         /// <summary>
533         /// T-Sql方式：返回IQueryable<T>集合（异步方式）
534         /// </summary>
535         /// <param name="sql">SQL语句</param>
536         /// <param name="para">Parameters参数</param>
537         /// <returns></returns>
538         public virtual async Task<IQueryable<T>> LoadAllBySqlAsync(string sql, params DbParameter[] para)
539         {
540             return await Task.Run(() => _Context.Set<T>().FromSql(sql, para));
541         }
542 
543 
544         /// <summary>
545         /// T-Sql方式：返回List<T>集合
546         /// </summary>
547         /// <param name="sql">SQL语句</param>
548         /// <param name="para">Parameters参数</param>
549         /// <returns></returns>
550         public virtual List<T> LoadListAllBySql(string sql, params DbParameter[] para)
551         {
552             return _Context.Set<T>().FromSql(sql, para).Cast<T>().ToList();
553         }
554         /// <summary>
555         /// T-Sql方式：返回List<T>集合（异步方式）
556         /// </summary>
557         /// <param name="sql">SQL语句</param>
558         /// <param name="para">Parameters参数</param>
559         /// <returns></returns>
560         public virtual async Task<List<T>> LoadListAllBySqlAsync(string sql, params DbParameter[] para)
561         {
562             return await Task.Run(()=> _Context.Set<T>().FromSql(sql, para).Cast<T>().ToList());
563         }
564 
565         /// <summary>
566         /// 可指定返回结果、排序、查询条件的通用查询方法，返回实体对象集合
567         /// </summary>
568         /// <typeparam name="TEntity">实体对象</typeparam>
569         /// <typeparam name="TOrderBy">排序字段类型</typeparam>
570         /// <typeparam name="TResult">数据结果，与TEntity一致</typeparam>
571         /// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
572         /// <param name="orderby">排序字段</param>
573         /// <param name="selector">返回结果（必须是模型中存在的字段）</param>
574         /// <param name="IsAsc">排序方向，true为正序false为倒序</param>
575         /// <returns>实体集合</returns>
576         public virtual List<TResult> QueryEntity<TEntity, TOrderBy, TResult>
577             (Expression<Func<TEntity, bool>> where,
578             Expression<Func<TEntity, TOrderBy>> orderby,
579             Expression<Func<TEntity, TResult>> selector,
580             bool IsAsc)
581             where TEntity : class
582             where TResult : class
583         {
584             IQueryable<TEntity> query = _Context.Set<TEntity>();
585             if (where != null)
586             {
587                 query = query.Where(where);
588             }
589 
590             if (orderby != null)
591             {
592                 query = IsAsc ? query.OrderBy(orderby) : query.OrderByDescending(orderby);
593             }
594             if (selector == null)
595             {
596                 return query.Cast<TResult>().AsNoTracking().ToList();
597             }
598             return query.Select(selector).AsNoTracking().ToList();
599         }
600         /// <summary>
601         /// 可指定返回结果、排序、查询条件的通用查询方法，返回实体对象集合（异步方式）
602         /// </summary>
603         /// <typeparam name="TEntity">实体对象</typeparam>
604         /// <typeparam name="TOrderBy">排序字段类型</typeparam>
605         /// <typeparam name="TResult">数据结果，与TEntity一致</typeparam>
606         /// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
607         /// <param name="orderby">排序字段</param>
608         /// <param name="selector">返回结果（必须是模型中存在的字段）</param>
609         /// <param name="IsAsc">排序方向，true为正序false为倒序</param>
610         /// <returns>实体集合</returns>
611         public virtual async Task<List<TResult>> QueryEntityAsync<TEntity, TOrderBy, TResult>
612             (Expression<Func<TEntity, bool>> where,
613             Expression<Func<TEntity, TOrderBy>> orderby,
614             Expression<Func<TEntity, TResult>> selector,
615             bool IsAsc)
616             where TEntity : class
617             where TResult : class
618         {
619             IQueryable<TEntity> query = _Context.Set<TEntity>();
620             if (where != null)
621             {
622                 query = query.Where(where);
623             }
624 
625             if (orderby != null)
626             {
627                 query = IsAsc ? query.OrderBy(orderby) : query.OrderByDescending(orderby);
628             }
629             if (selector == null)
630             {
631                 return await Task.Run(() => query.Cast<TResult>().AsNoTracking().ToList());
632             }
633             return await Task.Run(() => query.Select(selector).AsNoTracking().ToList());
634         }
635 
636         /// <summary>
637         /// 可指定返回结果、排序、查询条件的通用查询方法，返回Object对象集合
638         /// </summary>
639         /// <typeparam name="TEntity">实体对象</typeparam>
640         /// <typeparam name="TOrderBy">排序字段类型</typeparam>
641         /// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
642         /// <param name="orderby">排序字段</param>
643         /// <param name="selector">返回结果（必须是模型中存在的字段）</param>
644         /// <param name="IsAsc">排序方向，true为正序false为倒序</param>
645         /// <returns>自定义实体集合</returns>
646         public virtual List<object> QueryObject<TEntity, TOrderBy>
647             (Expression<Func<TEntity, bool>> where,
648             Expression<Func<TEntity, TOrderBy>> orderby,
649             Func<IQueryable<TEntity>,
650             List<object>> selector,
651             bool IsAsc)
652             where TEntity : class
653         {
654             IQueryable<TEntity> query = _Context.Set<TEntity>();
655             if (where != null)
656             {
657                 query = query.Where(where);
658             }
659 
660             if (orderby != null)
661             {
662                 query = IsAsc ? query.OrderBy(orderby) : query.OrderByDescending(orderby);
663             }
664             if (selector == null)
665             {
666                 return query.AsNoTracking().ToList<object>();
667             }
668             return selector(query);
669         }
670         /// <summary>
671         /// 可指定返回结果、排序、查询条件的通用查询方法，返回Object对象集合（异步方式）
672         /// </summary>
673         /// <typeparam name="TEntity">实体对象</typeparam>
674         /// <typeparam name="TOrderBy">排序字段类型</typeparam>
675         /// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
676         /// <param name="orderby">排序字段</param>
677         /// <param name="selector">返回结果（必须是模型中存在的字段）</param>
678         /// <param name="IsAsc">排序方向，true为正序false为倒序</param>
679         /// <returns>自定义实体集合</returns>
680         public virtual async Task<List<object>> QueryObjectAsync<TEntity, TOrderBy>
681             (Expression<Func<TEntity, bool>> where,
682             Expression<Func<TEntity, TOrderBy>> orderby,
683             Func<IQueryable<TEntity>,
684             List<object>> selector,
685             bool IsAsc)
686             where TEntity : class
687         {
688             IQueryable<TEntity> query = _Context.Set<TEntity>();
689             if (where != null)
690             {
691                 query = query.Where(where);
692             }
693 
694             if (orderby != null)
695             {
696                 query = IsAsc ? query.OrderBy(orderby) : query.OrderByDescending(orderby);
697             }
698             if (selector == null)
699             {
700                 return await Task.Run(() => query.AsNoTracking().ToList<object>());
701             }
702             return await Task.Run(() => selector(query));
703         }
704 
705 
706         /// <summary>
707         /// 可指定返回结果、排序、查询条件的通用查询方法，返回动态类对象集合
708         /// </summary>
709         /// <typeparam name="TEntity">实体对象</typeparam>
710         /// <typeparam name="TOrderBy">排序字段类型</typeparam>
711         /// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
712         /// <param name="orderby">排序字段</param>
713         /// <param name="selector">返回结果（必须是模型中存在的字段）</param>
714         /// <param name="IsAsc">排序方向，true为正序false为倒序</param>
715         /// <returns>动态类</returns>
716         public virtual dynamic QueryDynamic<TEntity, TOrderBy>
717             (Expression<Func<TEntity, bool>> where,
718             Expression<Func<TEntity, TOrderBy>> orderby,
719             Func<IQueryable<TEntity>,
720             List<object>> selector,
721             bool IsAsc)
722             where TEntity : class
723         {
724             List<object> list = QueryObject<TEntity, TOrderBy>
725                  (where, orderby, selector, IsAsc);
726             return Common.JsonHelper.JsonConvert.JsonClass(list);
727         }
728         /// <summary>
729         /// 可指定返回结果、排序、查询条件的通用查询方法，返回动态类对象集合（异步方式）
730         /// </summary>
731         /// <typeparam name="TEntity">实体对象</typeparam>
732         /// <typeparam name="TOrderBy">排序字段类型</typeparam>
733         /// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
734         /// <param name="orderby">排序字段</param>
735         /// <param name="selector">返回结果（必须是模型中存在的字段）</param>
736         /// <param name="IsAsc">排序方向，true为正序false为倒序</param>
737         /// <returns>动态类</returns>
738         public virtual async Task<dynamic> QueryDynamicAsync<TEntity, TOrderBy>
739             (Expression<Func<TEntity, bool>> where,
740             Expression<Func<TEntity, TOrderBy>> orderby,
741             Func<IQueryable<TEntity>,
742             List<object>> selector,
743             bool IsAsc)
744             where TEntity : class
745         {
746             List<object> list = QueryObject<TEntity, TOrderBy>
747                  (where, orderby, selector, IsAsc);
748             return await Task.Run(() => Common.JsonHelper.JsonConvert.JsonClass(list)) ;
749         }
750 
751         #endregion
752 
753         #region 验证是否存在
754 
755         /// <summary>
756         /// 验证当前条件是否存在相同项
757         /// </summary>
758         public virtual bool IsExist(Expression<Func<T, bool>> predicate)
759         {
760             var entry = _Context.Set<T>().Where(predicate);
761             return (entry.Any());
762         }
763         /// <summary>
764         /// 验证当前条件是否存在相同项（异步方式）
765         /// </summary>
766         public virtual async Task<bool> IsExistAsync(Expression<Func<T, bool>> predicate)
767         {
768             var entry = _Context.Set<T>().Where(predicate);
769             return await Task.Run(() => entry.Any());
770         }
771 
772         /// <summary>
773         /// 根据SQL验证实体对象是否存在
774         /// </summary>
775         public virtual bool IsExist(string sql, params DbParameter[] para)
776         {
777             return _Context.Database.ExecuteSqlCommand(sql, para) > 0;
778         }
779         /// <summary>
780         /// 根据SQL验证实体对象是否存在（异步方式）
781         /// </summary>
782         public virtual async Task<bool> IsExistAsync(string sql, params DbParameter[] para)
783         {
784             return await Task.Run(() => _Context.Database.ExecuteSqlCommand(sql, para) > 0);
785         }
786 
787         #endregion
788 
789     }