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 = 
            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
【無私分享：ASP.NET CORE 專案實戰（第五章）】Repository倉儲 UnitofWork
     
 
  1   public abstract class Repository<T> : IRepository<T> where T : class
  2     {
  3         #region 資料上下文
  4 
  5         /// <s 

  
 

    

    
    
【無私分享：ASP.NET CORE 專案實戰（第九章）】建立區域Areas，新增TagHelper
     
 
目錄索引



簡介


　　在Asp.net Core VS2015中，我們發現還有很多不太簡便的地方，比如右擊新增檢視，轉到試圖頁等功能圖不見了，雖然我們可以通過工具欄的自定義命令，把這兩個右擊選單新增上，但是貌似是灰色的不能用。
　　其實，這樣也好，通過手動建立，更讓我們深刻的理解M 

  
 

    

    
    
【無私分享：ASP.NET CORE 專案實戰（第十章）】釋出專案到 Linux 上執行 Core 專案
     
 
目錄索引



簡介


　　ASP.Net Core 給我們帶來的最大的亮點就是跨平臺，我在我電腦（win7）上用虛擬機器建了個 CentOS7 ,來演示下，我們windows上的專案如何釋出專案到Linux上執行。我這裡有個在windows上搭建過的程式，我們主要演示如何在linux上執 

  
 

    

    
    
【無私分享：ASP.NET CORE 專案實戰（第六章）】讀取配置檔案（一） appsettings.json
     
 
目錄索引



簡介

　　在我們之前的Asp.net mvc 開發中，一提到配置檔案，我們不由的想到 web.config 和 app.config，在 core 中，我們看到了很多的變化，新的配置系統顯得更加輕量級，具有更好的擴充套件性，並且支援多樣化的資料來源。
　　部落格園對於這個的 

  
 

    

    
    
【無私分享：ASP.NET CORE 專案實戰（第八章）】讀取配置檔案（二） 讀取自定義配置檔案
     
 
目錄索引



簡介


　　但隨之產生了問題：我們使用的是在 Startup.cs 中（如下圖）來實現配置讀取，有兩個問題 ① 我們如果定義N種配置，是否要再這裡新增N條這樣的配置 ； ② 如果我們的配置不想寫在appsettings.json中呢 
　　




解決問題
 

  
 

    

    
    
【無私分享：ASP.NET CORE 專案實戰（第十三章）】Asp.net Core 使用MyCat分散式資料庫，實現讀寫分離
     
 
目錄索引



簡介


　　MyCat2.0版本很快就釋出了，關於MyCat的動態和一些問題，大家可以加一下MyCat的官方QQ群：106088787。我們今天主要介紹一下，在我們的Asp.net Core中如何使用Mycat，這源於一個大神（Amamiya Yuuko）的分享，但是，這中 

  
 

    

    
    
【無私分享：ASP.NET CORE 專案實戰（第四章）】Code First 建立資料庫和資料表
     
 
目錄索引



簡介

　　本章我們來介紹下Asp.net Core 使用 CodeFirst 建立資料庫和表，通過 控制檯 和 dotnet ef 兩種方式


修改EF上下文物件，新增測試類

　　我修改了一下名字，Domains 改為了 wkmvc.Data
　　我們新建一個 

  
 

    

    
    
【無私分享：ASP.NET CORE 專案實戰（第七章）】檔案操作 FileHelper
     
 
目錄索引



簡介

　　在程式設計中，我們很多情況下，會用到對檔案的操作，在 上一個系列 中，我們有很多檔案基本操作的示例，在Core中有一些改變，主要是我們常用的Server.MapPath()不存在了，不知道後續的版本會不會有，在這裡，我們只能自己封裝方法去實現。今天，我們就對一些基本 

  
 

    

    
    
【無私分享：ASP.NET CORE 專案實戰（第三章）】EntityFramework下領域驅動設計的應用
     
 
這好像就是比我的多了一個“中轉層”，把我們的介面作為了一箇中轉，領域層繼承了倉儲實現業務和資料操作，這有什麼實際意義嗎？希望大家指正一下：
我不理解的是，如果是按照這樣，那麼我如果要修改註冊方法，比如我要在上面方法中傳遞 eamil,name,password 的基礎上還需要傳遞手機號碼，那麼我需要修改 

  
 

    

    
    
【無私分享：ASP.NET CORE 專案實戰（第十一章）】Asp.net Core 快取 MemoryCache 和 Redis
     
 
 1 /// <summary>
 2         /// 修改快取
 3         /// </summary>
 4         /// <param name="key">快取Key</param>
 5         ///  

  
 

    

    
    
【無私分享：ASP.NET CORE 專案實戰（第十二章）】新增對SqlServer、MySql、Oracle的支援
     
 
目錄索引



簡介


　　增加對多資料庫的支援，並不是意味著同時對多種資料庫操作，當然，後面，我們會嘗試同時對多種資料庫操作，這可能需要多個上下文，暫且不論。分散式資料庫，我們採用的是阿里雲的Mycat，這個後面會更新出來。我們今天的場景是：我們的專案可能是在windows上開發的使用的 

  
 

    

    
    
【無私分享：ASP.NET CORE 專案實戰（第十四章）】圖形驗證碼的實現
     
 
 1  public class VierificationCodeServices
 2     {
 3         /// <summary>  
 4         /// 該方法用於生成指定位數的隨機數  
 5         /// </summary>  
 6 

  
 

    

    
    
【無私分享：ASP.NET CORE 專案實戰（第二章）】新增EF上下文物件，新增介面、實現類以及無處不在的依賴注入（DI）
     
 
目錄索引



簡介

　　上一章，我們介紹了安裝和新建控制器、檢視，這一章我們來建立個數據模型，並且新增介面和實現類。


新增EF上下文物件

　　按照我們以前的習慣，我們還是新建幾個資料夾
　　Commons：存放幫助類
　　Domians：資料模型
　　Services 

  
 

    

    
    
ASP.NET Core 專案實戰（持續更新~~~）
     
  一、前言 
　　準備寫這個系列文章的設想開始於今年9月，毫無意外，期間又又又又拖了很長時間，文章主要是為了記錄自己學習使用 ASP.NET Core Web API 與 Vue 建立一個前後端分離的專案的整個過程。嗯，2018年快要結束了，應該能在 .NET Core 3.0 正式版和 Vue 3 

  
 

    

    
    
ASP.NET Core中使用GraphQL - 第五章 欄位, 引數, 變數
     
  
ASP.NET Core中使用GraphQL 
 
 ASP.NET Core中使用GraphQL - 第一章 Hello World 
 ASP.NET Core中使用GraphQL - 第二章 中介軟體 
 ASP.NET Core中使用GraphQL - 第三章 依賴注入 
 ASP.NET Cor 

  
 

    

    
    
ASP.NET Core 中文文件 第五章 測試（5.2）整合測試
     
 
整合測試確保應用程式的元件組裝在一起時正常工作。 ASP.NET Core支援使用單元測試框架和可用於處理沒有網路開銷請求的內建測試的網路主機整合測試。
章節：


整合測試介紹 
整合測試驗證應用程式不同的部位是否正確地組裝在一起。不像單元測試，整合測試經常涉及到應用基礎設施，如資料庫，檔案系統，網路資源 

  
 

    

    
    
乾貨分享：ASP.NET CORE（C#）與Spring Boot MVC(JAVA)異曲同工的程式設計方式總結
     
 
    目錄
    
        
        C# VS JAVA 基礎語法類比篇：
        一、匿名類
        二、型別初始化
        三、委託（方法引用）
        四、Lambda表示式
        五、泛型
        六、自動釋放
         

  
 

    

    
    
Asp.net core 專案實戰 新聞網站+後臺 原始碼、設計原理 、視訊教程
     
 首先說明，視訊教程、原始碼並非本人原創 
本人將專案分割開，並寫了一些說明。 
該視訊教程 地址  https://study.163.com/course/courseMain.htm?courseId=1005955006 
原作者 
 
筆者正在學 ASP.NET Core ，發現這 

  
 

    

    
    
ASP.NET Core中使用GraphQL - 第三章 依賴注入
     
  
ASP.NET Core中使用GraphQL 
 
 ASP.NET Core中使用GraphQL - 第一章 Hello World 
 ASP.NET Core中使用GraphQL - 第二章 中介軟體 
 
 
 
 SOLID原則中的D表示依賴倒置原則。這個原則的內容是： 
  
  上層模組不應 

  
 

    

    
    
Asp.net WebApi 專案示例（增刪改查）
     
  
 
 1.WebApi是什麼 
        ASP.NET Web API 是一種框架，用於輕鬆構建可以由多種客戶端（包括瀏覽器和移動裝置）訪問的 HTTP 服務。ASP.NET Web API 是一種用於在 .NET Framework 上構建 RESTful