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

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 之间的转化。

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

Model-First模式优点是开发人员能够在设计模型时完全了解数据库的结构以及表格之间的关系，但是缺点是在模型设计完后，还是需要去手动创建数据库，而且生成的脚本有点不简洁。

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

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

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 的理解。如需转载请表明！

 

posted @ 2017-07-14 15:42  LowKeyC  阅读(8919)  评论(12)  编辑  收藏  举报
有志者事竟成破釜沉舟百二秦关终属楚苦心人,天不负,卧薪尝胆,三千越甲可吞吴