关于EF 通用增删改查的封装

时间 2019-11-29

原文原文链接

1. Entity Framework是Microsoft的ORM框架，随着 Entity Framework 不断的完善强化已经到达了EF 6.0+ 仍是很是的完善的，目前使用的比例相对于其余ORM 的框架仍是比较多的。例若有咱们目前使用较多的是EF和Drapper 和SQL Sugar 以及NHibernate 固然NHibernate 我使用的很少。固然EF确实使用起来很是的方便开发的速度是比较快的，EF 毕竟在Microsoft 在.NET 体系中已经推出了多年了，不管是成熟度仍是其中的性能以及优化的程度都获得了很好很大的改善，因此仍是很是值得咱们学习使用，固然我这个不是吹嘘EF 好，并且有的朋友也说了 EF 性能很差效率不高，我想询问一下针对于这些问题你想过如何进行优化以及改进没有其实目前改进的方案网上仍是很是多的，固然也有不少开发者为EF提供了扩展功能，如Entity Framework Extended 等里面封装的一些方法就是很是好使用的。并且做为.NET 开发者来讲项目的通用性也是很是的强大的，资料也是很是多的，Microsoft在这块的更新力度也很给力。Entity Framework 提供了三种开发模式，Code Frist，Database-First,Model-First。目前采用Code Frist 的比较多一些，可是我建议你们可使用DB Frist 简单好用。操做方便。固然你若是你喜欢Code Frist 也是拥有本身的好处，反正三者之间都是相通的，没有什么难点的。都是ORM 之间的转化。sql

Database-First模式明显性能会差点，很是的适合初学者，或者是比较急的中小型项目通常状况下使用仍是足够的。（数据量200W左右仍是足够应付的）。数据库

Model-First模式优势是开发人员可以在设计模型时彻底了解数据库的结构以及表格之间的关系，可是缺点是在模型设计完后，仍是须要去手动建立数据库，并且生成的脚本有点不简洁。缓存

Code-First模式有点不用说了，就是上面两个模式的缺点。缺点应该也是有不少的，好比更新数据库。涉及到数据的迁移这一块。就让大多数人比较头疼。目前解决的方案比较多。并发

这个这个只是我我的的意见和见解。因此关于这个EF 的开发模式的如何的使用，决定权利在于你的项目和数据库数据量大小和你公司的目前存在的框架。app

2. 关于我我的封装的通用的EF 比较简单好用就是正对于数据库的CRUD ，并且很是适合于单个数据库的读写的操做。固然你也能够进行对于数据库进行读写分离的操做，创建相互对应的数据库的集群，那么其实说白了 EF自己就是一个对于CRUD 的读写的操做。使用过EF的人知道，EF提供访问数据库的是 DbContext 这个对象，因此想实现读写分离的就很简单了，只要在程序中使用两个不一样的DbContext对象，一个负责读，一个负责写就行了。固然你也能够进行使用相对应的工厂化模式进行读写分离的操做也能够经过经常使用的反射来进行读写的操做，决定权取决在你的手上。因此咱们在使用其中的读写分离的时候你只管进行对于 DbContext 进行操做就是了创建相互对于的读写的类就能够了。通常读写进行分离的都是进行同步于主库的。由于通常状况下的读写的分离都是一主多从库的模式。框架

3.在使用这个通用EF CRUD 类的时候须要进行添加EntityFramework.Extended.6.1.0.168 EntityFramework 6.1.3 两个程序集。固然我这里使用的是MySQL 数据库因此还添加MySQL Data Entity 的等等。添加以上引用的程序集就能够了。而后还须要添加相对应的Transaction的程序集，这个时候有的朋友就问了添加Transaction作什么个人目的就是经过创建想对应的事务来进行回滚处理简单的并发要作所有都作，要么所有都不作。若是你采用Queue 来进行解决并发那就更好了。其中关于EF 的CRUD 的通用代码以下。性能

 1 using System;  2 using System.Collections.Generic;  3 using System.Linq.Expressions;  4 using System.Data;  5 using MySql.Data.MySqlClient;  6 /************************************************  7 ◇做者： LowKeyC  8 ◇说明： 定义一个EF通用的CRUD的接口  9 ◇版本号：V1.0  10 ◇建立日期：2017年6月22日 星期四  11 *****************************************************/
 12 
 13 namespace EFCommon.SqlHelp  14 {  15     public interface IRepository : IDisposable  16  {  17 
 18         /// <summary>
 19         /// 添加实体  20         /// </summary>
 21         /// <typeparam name="T"></typeparam>
 22         /// <param name="Entity"></param>
 23         /// <returns></returns>
 24         bool Add<T>(T Entity) where T : class;  25 
 26         /// <summary>
 27         /// 批量的进行添加实体  28         /// </summary>
 29         /// <typeparam name="T"></typeparam>
 30         /// <param name="Entity"></param>
 31         /// <returns></returns>
 32         bool AddRange<T>(List<T> Entity) where T : class;  33 
 34 
 35         /// <summary>
 36         /// 删除单个实体  37         /// </summary>
 38         /// <typeparam name="T"></typeparam>
 39         /// <param name="Entity"></param>
 40         /// <returns></returns>
 41         bool Delete<T>(T Entity) where T : class;  42 
 43         /// <summary>
 44         /// 根据查询条件进行删除单个实体  45         /// </summary>
 46         /// <typeparam name="T"></typeparam>
 47         /// <param name="whereLambda"></param>
 48         /// <returns></returns>
 49         bool Delete<T>(Expression<Func<T, bool>> whereLambda) where T : class;  50          
 51 
 52         /// <summary>
 53         ///单个对象的修改  54         /// </summary>
 55         /// <typeparam name="T"></typeparam>
 56         /// <param name="Entity">须要修改的对象</param>
 57         /// <returns></returns>
 58         bool Update<T>(T Entity) where T : class;  59 
 60 
 61         /// <summary>
 62         /// 批量修改  63         /// </summary>
 64         /// <typeparam name="T"></typeparam>
 65         /// <param name="whereLambda"></param>
 66         /// <param name="updateLambda"></param>
 67         /// <returns></returns>
 68         bool Update<T>(Expression<Func<T, bool>> WhereLambda, Expression<Func<T, T>> UpdateLambda) where T : class;  69 
 70 
 71         /// <summary>
 72         /// 批量的修改  73         /// </summary>
 74         /// <typeparam name="T"></typeparam>
 75         /// <param name="Entity"></param>
 76         /// <returns></returns>
 77         bool Update<T>(List<T> Entity) where T : class;  78 
 79 
 80         /// <summary>
 81         /// 批量统一的进行更新  82         /// </summary>
 83         /// <typeparam name="T"></typeparam>
 84         /// <param name="model">须要修改的对象实体</param>
 85         /// <param name="WhereLambda">查询的条件</param>
 86         /// <param name="ModifiedProNames"></param>
 87         /// <returns></returns>
 88         bool Update<T>(T model, Expression<Func<T, bool>> WhereLambda, params string[] ModifiedProNames) where T : class;  89 
 90 
 91         /// <summary>
 92         /// 根据主键进行查询  93         /// </summary>
 94         /// <typeparam name="T"></typeparam>
 95         /// <param name="ID"></param>
 96         /// <returns></returns>
 97         T FindByID<T>(dynamic ID) where T : class;  98 
 99         /// <summary>
100         /// 默认查询选择第一条数据,没有那么进行返回NULL 101         /// </summary>
102         /// <typeparam name="T"></typeparam>
103         /// <param name="WhereLambda"></param>
104         /// <returns>返回bool</returns>
105         T GetFristDefault<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class; 106 
107         /// <summary>
108         /// 查询全部的数据 109         /// </summary>
110         /// <typeparam name="T"></typeparam>
111         /// <returns></returns>
112         List<T> GetAll<T>(string Order = null) where T : class; 113 
114         /// <summary>
115         /// 含有带条件的查询 116         /// </summary>
117         /// <typeparam name="T"></typeparam>
118         /// <param name="WhereLambda"></param>
119         /// <returns></returns>
120         List<T> GetAllQuery<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class; 121 
122 
123         /// <summary>
124         ///获取查询的数量 125         /// </summary>
126         /// <typeparam name="T"></typeparam>
127         /// <param name="WhereLambda"></param>
128         /// <returns></returns>
129         int GetCount<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class; 130 
131         /// <summary>
132         /// 判断对象是否存在 133         /// </summary>
134         /// <typeparam name="T"></typeparam>
135         /// <param name="WhereLambda"></param>
136         /// <returns></returns>
137         bool GetAny<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class; 138 
139 
140         /// <summary>
141         /// 根据查询过条件进行分页 142         /// </summary>
143         /// <typeparam name="T"></typeparam>
144         /// <typeparam name="TKey"></typeparam>
145         /// <param name="PageIndex">当前页面</param>
146         /// <param name="PageSize">页面的大小</param>
147         /// <param name="TotalCount">总记录数</param>
148         /// <param name="OrderBy">排序的条件</param>
149         /// <param name="WhereLambda">查询条件</param>
150         /// <param name="IsOrder">是否正序</param>
151         /// <returns></returns>
152         List<T> Pagination<T, TKey>(int PageIndex, int PageSize, out int TotalCount, Expression<Func<T, TKey>> OrderBy, Expression<Func<T, bool>> WhereLambda = null, bool IsOrder = true) where T : class; 153 
154 
155         /// <summary>
156         /// 根据查询条件进行作分页查询 157         /// </summary>
158         /// <typeparam name="T">查询的对象</typeparam>
159         /// <param name="PageIndex">当前的页码</param>
160         /// <param name="PageSize">每页的大小</param>
161         /// <param name="TotalCount">总页数</param>
162         /// <param name="ordering">排序条件</param>
163         /// <param name="WhereLambda">查询条件</param>
164         /// <returns></returns>
165         List<T> Pagination<T>(int PageIndex, int PageSize, out int TotalCount, string ordering, Expression<Func<T, bool>> WhereLambda = null) where T : class; 166 
167 
168         /// <summary>
169         /// 根据查询条件进行转化 170         /// </summary>
171         /// <typeparam name="T"></typeparam>
172         /// <param name="WhereLambda"></param>
173         /// <returns></returns>
174         List<T> GetSelect<T>(Expression<Func<T, bool>> WhereLambda) where T : class; 175 
176 
177         /// <summary>
178         /// 执行存储过程或自定义sql语句--返回集合 179         /// </summary>
180         /// <typeparam name="T"></typeparam>
181         /// <param name="Sql"></param>
182         /// <param name="Parms"></param>
183         /// <param name="CmdType"></param>
184         /// <returns></returns>
185         List<T> QueryPro<T>(string Sql, List<MySqlParameter> Parms, CommandType CmdType = CommandType.Text) where T : class; 186 
187 
188         /// <summary>
189         /// 回滚 190         /// </summary>
191         /// <typeparam name="T"></typeparam>
192         void RollBackChanges<T>() where T : class; 193 
194  } 195 }

4.关于如何实现以上接口的方法。以下面代码所示。固然你也能够将进行实例化对象这里进行采用简单工厂或者抽象工厂全凭我的想法。学习

 1 using System;  2 using System.Collections.Generic;  3 using System.Linq;  4 using System.Text;  5 using System.Transactions;  6 using System.Data.Entity;  7 using System.Linq.Expressions;  8 using System.Data;  9 using System.Linq.Dynamic;  10 using EntityFramework.Extensions;  11 using System.Reflection;  12 using System.Data.Entity.Infrastructure;  13 using MySql.Data.MySqlClient;  14 /************************************************  15 ◇做者： LowKeyC 须要引用这个程序集:EntityFramework.Extended.6.1.0.168  16 ◇说明： 实现EF通用的CRUD通用的接口  17 ◇版本号：V1.0  18 ◇建立日期：2017年6月22日 星期四  19 *****************************************************/
 20 namespace EFCommon.SqlHelp  21 {  22     public class Repository : IRepository, IDisposable  23  {  24 
 25         private readonly static  DbContext _DbContextHandle =new ahavadbEntities();//此处进行调用EF的DBContent 的实体类或者经过工厂化模式来进行调用。
 26 
 27         /// <summary>
 28         /// 添加一个对象  29         /// </summary>
 30         /// <typeparam name="T"></typeparam>
 31         /// <param name="Entity"></param>
 32         /// <returns></returns>
 33         public bool Add<T>(T Entity) where T : class
 34  {  35             using (TransactionScope Ts = new TransactionScope(TransactionScopeOption.Required))  36  {  37                 _DbContextHandle.Set<T>().Add(Entity);  38                 int Count = _DbContextHandle.SaveChanges();  39  Ts.Complete();  40                 return Count > 0;  41  }  42  }  43 
 44         /// <summary>
 45         /// 批量的插入数据  46         /// </summary>
 47         /// <typeparam name="T"></typeparam>
 48         /// <param name="Entity"></param>
 49         /// <returns></returns>
 50         public bool AddRange<T>(List<T> Entity) where T : class
 51  {  52             using (TransactionScope Ts = new TransactionScope(TransactionScopeOption.Required))  53  {  54                 _DbContextHandle.Set<T>().AddRange(Entity);  55                 int Count = _DbContextHandle.SaveChanges();  56  Ts.Complete();  57                 return Count > 0;  58  }  59  }  60 
 61         /// <summary>
 62         /// 根据查询条件进行删除对象  63         /// </summary>
 64         /// <typeparam name="T"></typeparam>
 65         /// <param name="whereLambda">查询条件</param>
 66         /// <returns></returns>
 67         public bool Delete<T>(Expression<Func<T, bool>> whereLambda) where T : class
 68  {  69             using (TransactionScope Ts = new TransactionScope(TransactionScopeOption.Required))  70  {  71                 var EntityModel = _DbContextHandle.Set<T>().Where(whereLambda).FirstOrDefault();  72                 if (EntityModel != null)  73  {  74                     _DbContextHandle.Set<T>().Remove(EntityModel);  75                     int Count = _DbContextHandle.SaveChanges();  76  Ts.Complete();  77                     return Count > 0;  78  }  79                 return false;  80  }  81  }  82 
 83 
 84         /// <summary>
 85         /// 删除单个对象的实体  86         /// </summary>
 87         /// <typeparam name="T"></typeparam>
 88         /// <param name="Entity">实体对象</param>
 89         /// <returns></returns>
 90         public bool Delete<T>(T Entity) where T : class
 91  {  92             using (TransactionScope Ts = new TransactionScope(TransactionScopeOption.Required))  93  {  94                 _DbContextHandle.Set<T>().Attach(Entity);  95                 _DbContextHandle.Set<T>().Remove(Entity);  96                 int Count = _DbContextHandle.SaveChanges();  97  Ts.Complete();  98                 return Count > 0;  99  } 100  } 101 
102         /// <summary>
103         /// 批量的进行更新数据 104         /// </summary>
105         /// <typeparam name="T"></typeparam>
106         /// <param name="Entity"></param>
107         /// <returns></returns>
108         public bool Update<T>(List<T> Entity) where T : class
109  { 110             int Count = 0; 111             using (TransactionScope Ts = new TransactionScope(TransactionScopeOption.Required)) 112  { 113                 if (Entity != null) 114  { 115                     foreach (var items in Entity) 116  { 117                         var EntityModel = _DbContextHandle.Entry(Entity); 118                         _DbContextHandle.Set<T>().Attach(items); 119                         EntityModel.State = EntityState.Modified; 120  } 121 
122  } 123                 Count = _DbContextHandle.SaveChanges(); 124  Ts.Complete(); 125  } 126 
127             return Count > 0; 128  } 129 
130 
131         /// <summary>
132         /// 进行修改单个实体对象 133         /// </summary>
134         /// <typeparam name="T"></typeparam>
135         /// <param name="Entity">实体对象</param>
136         /// <returns></returns>
137         public bool Update<T>(T Entity) where T : class
138  { 139             using (TransactionScope Ts = new TransactionScope()) 140  { 141                 var EntityModel = _DbContextHandle.Entry<T>(Entity); 142                 _DbContextHandle.Set<T>().Attach(Entity); 143                 EntityModel.State = EntityState.Modified; 144                 int Count = _DbContextHandle.SaveChanges(); 145  Ts.Complete(); 146                 return Count > 0; 147  } 148  } 149 
150         /// <summary>
151         /// 批量的修改 152         /// </summary>
153         /// <typeparam name="T"></typeparam>
154         /// <param name="WhereLambda"></param>
155         /// <param name="UpdateLambda"></param>
156         /// <returns></returns>
157         public bool Update<T>(Expression<Func<T, bool>> WhereLambda, Expression<Func<T, T>> UpdateLambda) where T : class
158  { 159             _DbContextHandle.Set<T>().Where(WhereLambda).Update<T>(UpdateLambda); 160             return _DbContextHandle.SaveChanges() > 0; 161  } 162 
163 
164         /// <summary>
165         /// 查询条件进行修改 166         /// </summary>
167         /// <typeparam name="T"></typeparam>
168         /// <param name="model"></param>
169         /// <param name="WhereLambda"></param>
170         /// <param name="ModifiedProNames"></param>
171         /// <returns></returns>
172         public bool Update<T>(T model, Expression<Func<T, bool>> WhereLambda, params string[] ModifiedProNames) where T : class
173  { 174             //查询要修改的数据
175             List<T> ListModifing = _DbContextHandle.Set<T>().Where(WhereLambda).ToList(); 176             Type t = typeof(T); 177             List<PropertyInfo> ProInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList(); 178             Dictionary<string, PropertyInfo> DitProList = new Dictionary<string, PropertyInfo>(); 179             ProInfos.ForEach(p =>
180  { 181                 if (ModifiedProNames.Contains(p.Name)) 182  { 183  DitProList.Add(p.Name, p); 184  } 185  }); 186 
187             if (DitProList.Count <= 0) 188  { 189                 throw new Exception("指定修改的字段名称有误或为空"); 190  } 191             foreach (var item in DitProList) 192  { 193                 PropertyInfo proInfo = item.Value; 194                 object newValue = proInfo.GetValue(model, null); 195                 //批量进行修改相互对应的属性
196                 foreach (T oModel in ListModifing) 197  { 198                     proInfo.SetValue(oModel, newValue, null);//设置其中新的值
199  } 200  } 201 
202             return _DbContextHandle.SaveChanges() > 0; 203  } 204         /// <summary>
205         /// 释放缓存 206         /// </summary>
207         public void Dispose() 208  { 209  _DbContextHandle.Dispose(); 210  } 211 
212         /// <summary>
213         /// 查询单个对象 214         /// </summary>
215         /// <typeparam name="T"></typeparam>
216         /// <param name="ID">主键ID</param>
217         /// <returns></returns>
218         public T FindByID<T>(dynamic ID) where T : class
219  { 220             return _DbContextHandle.Set<T>().Find(ID) ?? null; 221  } 222 
223 
224         /// <summary>
225         /// 获取所有数据的列表 226         /// </summary>
227         /// <typeparam name="T"></typeparam>
228         /// <param name="Order">排序</param>
229         /// <returns></returns>
230         public List<T> GetAll<T>(string Order = null) where T : class
231  { 232             return Order != null ? _DbContextHandle.Set<T>().OrderBy(Order).ToList() ?? null : _DbContextHandle.Set<T>().ToList() ?? null; 233  } 234 
235         /// <summary>
236         ///根据查询条件进行查询列表 237         /// </summary>
238         /// <typeparam name="T"></typeparam>
239         /// <param name="WhereLambda"></param>
240         /// <returns></returns>
241         public List<T> GetAllQuery<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class
242  { 243             return WhereLambda != null ? _DbContextHandle.Set<T>().Where(WhereLambda).ToList() ?? null : _DbContextHandle.Set<T>().ToList() ?? null; 244  } 245 
246         /// <summary>
247         ///判断对象是否存在 248         /// </summary>
249         /// <typeparam name="T"></typeparam>
250         /// <param name="WhereLambda"></param>
251         /// <returns></returns>
252         public bool GetAny<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class
253  { 254             return WhereLambda != null ? _DbContextHandle.Set<T>().Where(WhereLambda).Any() : _DbContextHandle.Set<T>().Any(); 255  } 256 
257         /// <summary>
258         /// 获取查询条件的记录数 259         /// </summary>
260         /// <typeparam name="T"></typeparam>
261         /// <param name="WhereLambda"></param>
262         /// <returns></returns>
263         public int GetCount<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class
264  { 265             return WhereLambda != null ? _DbContextHandle.Set<T>().Where(WhereLambda).Count() : _DbContextHandle.Set<T>().Count(); 266  } 267 
268 
269         /// <summary>
270         /// 获取单条的记录 271         /// </summary>
272         /// <typeparam name="T"></typeparam>
273         /// <param name="WhereLambda"></param>
274         /// <returns></returns>
275         public T GetFristDefault<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class
276  { 277             return WhereLambda != null ? _DbContextHandle.Set<T>().Where(WhereLambda).FirstOrDefault() ?? null : _DbContextHandle.Set<T>().FirstOrDefault() ?? null; 278  } 279 
280 
281         /// <summary>
282         /// 查询对象的转化 283         /// </summary>
284         /// <typeparam name="T"></typeparam>
285         /// <param name="WhereLambda"></param>
286         /// <returns></returns>
287         public List<T> GetSelect<T>(Expression<Func<T, bool>> WhereLambda) where T : class
288  { 289             return _DbContextHandle.Set<T>().Where(WhereLambda).ToList() ?? null; 290  } 291 
292         /// <summary>
293         ///根据查询条件进行分页 294         /// </summary>
295         /// <typeparam name="T"></typeparam>
296         /// <param name="PageIndex">当前页</param>
297         /// <param name="PageSize">每页的大小</param>
298         /// <param name="TotalCount">总记录数</param>
299         /// <param name="ordering">排序条件</param>
300         /// <param name="WhereLambda">查询条件</param>
301         /// <returns></returns>
302         public List<T> Pagination<T>(int PageIndex, int PageSize, out int TotalCount, string Ordering, Expression<Func<T, bool>> WhereLambda = null) where T : class
303  { 304             //分页的时候必定要注意 Order 必定在Skip 以前
305             var QueryList = _DbContextHandle.Set<T>().OrderBy(Ordering); 306             if (WhereLambda != null) 307  { 308                 QueryList = QueryList.Where(WhereLambda); 309  } 310 
311             TotalCount = QueryList.Count(); 312             return QueryList.Skip(PageSize * (PageIndex - 1)).Take(PageSize).ToList() ?? null; 313  } 314 
315         /// <summary>
316         ///根据查询条件进行分页 317         /// </summary>
318         /// <typeparam name="T"></typeparam>
319         /// <param name="PageIndex">当前页</param>
320         /// <param name="PageSize">每页的大小</param>
321         /// <param name="TotalCount">总记录数</param>
322         /// <param name="OrderBy">排序条件</param>
323         /// <param name="WhereLambda">查询的条件</param>
324         /// <param name="IsOrder"></param>
325         /// <returns></returns>
326         public List<T> Pagination<T, TKey>(int PageIndex, int PageSize, out int TotalCount, Expression<Func<T, TKey>> OrderBy, Expression<Func<T, bool>> WhereLambda = null, bool IsOrder = true) where T : class
327  { 328             //分页的时候必定要注意 Order必定在Skip 以前
329             IQueryable<T> QueryList = IsOrder == true ? _DbContextHandle.Set<T>().OrderBy(OrderBy) : _DbContextHandle.Set<T>().OrderByDescending(OrderBy); 330 
331             if (WhereLambda != null) 332  { 333                 QueryList = QueryList.Where(WhereLambda); 334  } 335 
336             TotalCount = QueryList.Count(); 337             return QueryList.Skip(PageSize * (PageIndex - 1)).Take(PageSize).ToList() ?? null; 338  } 339 
340 
341         /// <summary>
342         /// 执行存储过程的SQL 语句 343         /// </summary>
344         /// <typeparam name="T"></typeparam>
345         /// <param name="Sql">执行的SQL语句</param>
346         /// <param name="Parms">SQL 语句的参数</param>
347         /// <param name="CmdType"></param>
348         /// <returns></returns>
349         public List<T> QueryPro<T>(string Sql, List<MySqlParameter> Parms, CommandType CmdType = CommandType.Text) where T : class
350  { 351             //进行执行存储过程
352             if (CmdType == CommandType.StoredProcedure) 353  { 354                 StringBuilder paraNames = new StringBuilder(); 355                 foreach (var item in Parms) 356  { 357                     paraNames.Append($" @{item},"); 358  } 359                 Sql = paraNames.Length > 0 ? $"exec {Sql} {paraNames.ToString().Trim(',')}" : $"exec {Sql} "; 360  } 361             return _DbContextHandle.Set<T>().SqlQuery(Sql, Parms.ToArray()).ToList(); 362  } 363 
364 
365         /// <summary>
366         /// 进行回滚 367         /// </summary>
368         /// <typeparam name="T"></typeparam>
369         public void RollBackChanges<T>() where T : class
370  { 371             var Query = _DbContextHandle.ChangeTracker.Entries().ToList(); 372 
373             Query.ForEach(p => p.State = EntityState.Unchanged); 374  } 375 
376  } 377 }

以上内容所有是基于原创部分观点引用了百度百科以及我的的对于EF 的理解。如需转载请代表！优化