關於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 的理解。如需轉載請代表！