.netCore+Vue 搭建的簡捷開發框架 （2）--倉儲層實現和EFCore 的使用

来源:https://www.cnblogs.com/xuzhencheng/archive/2019/08/28/11422025.html
-Advertisement-
Play Games

書接上文，繼續搭建我們基於.netCore 的開發框架。首先是我們的項目分層結構。 這個分層結構，是參考張老師的分層結構，但是實際項目中，我沒有去實現倉儲模型。因為我使用的是EFCore ,最近也一直在想，EFCore 在我們的架構體系中到底扮演著什麼樣的角色？？ 當然，實現倉儲層，也有他的好處，如 ...


書接上文，繼續搭建我們基於.netCore 的開發框架。首先是我們的項目分層結構。

 

這個分層結構，是參考張老師的分層結構，但是實際項目中，我沒有去實現倉儲模型。因為我使用的是EFCore ,最近也一直在想，EFCore 在我們的架構體系中到底扮演著什麼樣的角色？？

當然，實現倉儲層，也有他的好處，如果真的以後要更換ORM框架的時候，不用去更改服務層邏輯，不用直接在倉儲裡面做更改就可以了。但是對於小項目，可能運行個十年都不會換資料庫，不會換ORM的項目，倉儲層的意義在哪？

希望對此有自己想法的朋友一起討論。在本系列里，我將保留倉儲層。

上面的分層結構，很容易就搭建好了，但是基於.NetCore 的項目，可能最主要的一點就是如何利用好DI，怎麼來實現依賴註入。

依照上圖中的依賴關係，我們以此構建自己相應層級中的內容。

分別在IRepository和Repository項目下，新建Base文件夾，並分別建立IBaseRepository和BaseRepository

具體代碼如下：

IBaseRepository.cs：

 1 using Sincere.Core.Model;
 2 using System;
 3 using System.Collections.Generic;
 4 using System.Data;
 5 using System.Data.SqlClient;
 6 using System.Linq.Expressions;
 7 using System.Text;
 8 using System.Threading.Tasks;
 9 
10 namespace Sincere.Core.IRepository.Base
11 {
12     public interface IBaseRepository<TEntity> where TEntity : class
13     {
14         Task<int> Execute(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text);
15         Task<List<TEntity>> Query(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text);
16         Task<bool> Insert(TEntity model);
17         Task<bool> InsertRange(List<TEntity> datas);
18 
19         Task<int> Del(TEntity model);
20 
21         Task<int> DelBy(Expression<Func<TEntity, bool>> delWhere);
22 
23         Task<int> Modify(TEntity model);
24 
25         Task<int> Modify(TEntity model, params string[] propertyNames);
26 
27         Task<int> ModifyBy(TEntity model, Expression<Func<TEntity, bool>> whereLambda, params string[] modifiedPropertyNames);
28 
29         Task<List<TEntity>> GetList();
30 
31         Task<List<TEntity>> GetListBy(Expression<Func<TEntity, bool>> whereLambda);
32 
33         Task<TEntity> GetModelById(Expression<Func<TEntity, bool>> whereLambda);
34 
35         Task<List<TEntity>> GetListBy<TKey>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true);
36 
37         Task<List<TEntity>> GetListBy<TKey>(int top, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true);
38 
39         Task<List<TEntity>> GetListBy<TKey1, TKey2>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey1>> orderLambda1, Expression<Func<TEntity, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true);
40 
41         Task<List<TEntity>> GetListBy<TKey1, TKey2>(int top, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey1>> orderLambda1, Expression<Func<TEntity, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true);
42 
43         Task<List<TEntity>> GetPagedList<TKey>(int pageIndex, int pageSize, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true);
44 
45         Task<PageModel<TEntity>> GetPagedList<TKey>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true, int pageIndex = 1, int pageSize = 20);
46 
47         void RollBackChanges();
48 
49     }
50 }
View Code

BaseRepository.cs：

  1 using Microsoft.EntityFrameworkCore;
  2 using Sincere.Core.IRepository.Base;
  3 using Sincere.Core.Model;
  4 using Sincere.Core.Model.Models;
  5 using System;
  6 using System.Collections.Generic;
  7 using System.Data;
  8 using System.Data.SqlClient;
  9 using System.Linq;
 10 using System.Linq.Expressions;
 11 using System.Reflection;
 12 using System.Text;
 13 using System.Threading.Tasks;
 14 
 15 namespace Sincere.Core.Repository.Base
 16 {
 17     public class BaseRepository<TEntity> : IBaseRepository<TEntity> where TEntity : class, new()
 18     {
 19         private BaseCoreContext _db;
 20         private readonly DbSet<TEntity> _dbSet;
 21 
 22         internal BaseCoreContext Db
 23         {
 24             get { return _db; }
 25             private set { _db = value; }
 26         }
 27         public BaseRepository(IBaseContext mydbcontext)
 28         {
 29             this._db = mydbcontext as BaseCoreContext;
 30             this._dbSet = _db.Set<TEntity>();
 31         }
 32 
 33         #region INSERT
 34 
 35         /// <summary>
 36         /// 新增 實體
 37         /// </summary>
 38         /// <param name="model"></param>
 39         /// <returns></returns>
 40         //public async Task<bool> Insert(TEntity model, bool isSaveChanges = false)
 41         public async Task<bool> Insert(TEntity model)
 42         {
 43             _db.Set<TEntity>().Add(model);
 44             //if (isSaveChanges)
 45             //{
 46             return await _db.SaveChangesAsync() > 0;
 47             //}
 48             //else
 49             //{
 50             //    return false;
 51             //}
 52 
 53         }
 54 
 55         /// <summary>
 56         /// 普通批量插入
 57         /// </summary>
 58         /// <param name="datas"></param>
 59         public async Task<bool> InsertRange(List<TEntity> datas)
 60         {
 61             await _db.Set<TEntity>().AddRangeAsync(datas);
 62             return await _db.SaveChangesAsync() == datas.Count;
 63         }
 64 
 65         #endregion INSERT
 66 
 67         #region Delete
 68 
 69         #region 2.0 根據id刪除 +  int Del(T model)
 70         /// <summary>
 71         /// 2.0 根據id刪除
 72         /// </summary>
 73         /// <param name="model">必須包含要刪除id的對象</param>
 74         /// <returns></returns>
 75         public async Task<int> Del(TEntity model)
 76         {
 77             _db.Set<TEntity>().Attach(model);
 78             _db.Set<TEntity>().Remove(model);
 79             return await _db.SaveChangesAsync();
 80         }
 81         #endregion
 82 
 83         #region 2.1 根據條件刪除 + int DelBy(Expression<Func<T, bool>> delWhere)
 84         /// <summary>
 85         /// 2.1 根據條件刪除
 86         /// </summary>
 87         /// <param name="delWhere"></param>
 88         /// <returns>返回受影響的行數</returns>
 89         public async Task<int> DelBy(Expression<Func<TEntity, bool>> delWhere)
 90         {
 91             //2.1.1 查詢要刪除的數據
 92             List<TEntity> listDeleting = _db.Set<TEntity>().Where(delWhere).ToList();
 93             //2.1.2 將要刪除的數據 用刪除方法添加到 EF 容器中
 94             listDeleting.ForEach(u =>
 95             {
 96                 _db.Set<TEntity>().Attach(u);  //先附加到EF 容器
 97                 _db.Set<TEntity>().Remove(u); //標識為刪除狀態
 98             });
 99             //2.1.3 一次性生成sql語句 到資料庫執行刪除
100             return await _db.SaveChangesAsync();
101         }
102         #endregion
103 
104 
105         #endregion
106 
107         #region UPDATE
108 
109         #region 3.0 修改實體 +  int Modify(T model)
110         /// <summary>
111         /// 修改實體
112         /// </summary>
113         /// <param name="model"></param>
114         /// <returns></returns>
115         public async Task<int> Modify(TEntity model)
116         {
117             //EntityEntry entry = _db.Entry<TEntity>(model);
118             _db.Set<TEntity>().Update(model);
119             return await _db.SaveChangesAsync();
120         }
121         #endregion
122 
123         #region 3.1 修改實體，可修改指定屬性 + int Modify(T model, params string[] propertyNames)
124         /// <summary>
125         /// 3.1 修改實體，可修改指定屬性
126         /// </summary>
127         /// <param name="model"></param>
128         /// <param name="propertyName"></param>
129         /// <returns></returns>
130         public async Task<int> Modify(TEntity model, params string[] propertyNames)
131         {
132             //3.1.1 將對象添加到EF中
133             EntityEntry entry = _db.Entry<TEntity>(model);
134             //3.1.2 先設置對象的包裝狀態為 Unchanged
135             entry.State = EntityState.Unchanged;
136             //3.1.3 迴圈被修改的屬性名數組
137             foreach (string propertyName in propertyNames)
138             {
139                 //將每個被修改的屬性的狀態設置為已修改狀態；這樣在後面生成的修改語句時，就只為標識為已修改的屬性更新
140                 entry.Property(propertyName).IsModified = true;
141             }
142             return await _db.SaveChangesAsync();
143         }
144         #endregion
145 
146         #region 3.2 批量修改 + int ModifyBy(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedPropertyNames)
147         /// <summary>
148         /// 3.2 批量修改
149         /// </summary>
150         /// <param name="model"></param>
151         /// <param name="whereLambda"></param>
152         /// <param name="modifiedPropertyNames"></param>
153         /// <returns></returns>
154         public async Task<int> ModifyBy(TEntity model, Expression<Func<TEntity, bool>> whereLambda, params string[] modifiedPropertyNames)
155         {
156             //3.2.1 查詢要修改的數據
157             List<TEntity> listModifing = _db.Set<TEntity>().Where(whereLambda).ToList();
158             //3.2.2 獲取實體類類型對象
159             Type t = typeof(TEntity);
160             //3.2.3 獲取實體類所有的公共屬性
161             List<PropertyInfo> propertyInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
162             //3.2.4 創建實體屬性字典集合
163             Dictionary<string, PropertyInfo> dicPropertys = new Dictionary<string, PropertyInfo>();
164             //3.2.5 將實體屬性中要修改的屬性名 添加到字典集合中  鍵：屬性名  值：屬性對象
165             propertyInfos.ForEach(p =>
166             {
167                 if (modifiedPropertyNames.Contains(p.Name))
168                 {
169                     dicPropertys.Add(p.Name, p);
170                 }
171             });
172             //3.2.6 迴圈要修改的屬性名
173             foreach (string propertyName in modifiedPropertyNames)
174             {
175                 //判斷要修改的屬性名是否在實體類的屬性集合中存在
176                 if (dicPropertys.ContainsKey(propertyName))
177                 {
178                     //如果存在，則取出要修改的屬性對象
179                     PropertyInfo proInfo = dicPropertys[propertyName];
180                     //取出要修改的值
181                     object newValue = proInfo.GetValue(model, null);
182                     //批量設置要修改對象的屬性
183                     foreach (TEntity item in listModifing)
184                     {
185                         //為要修改的對象的要修改的屬性設置新的值
186                         proInfo.SetValue(item, newValue, null);
187                     }
188                 }
189             }
190             //一次性生成sql語句 到資料庫執行
191             return await _db.SaveChangesAsync();
192         }
193         #endregion
194 
195 
196         #endregion UPDATE
197 
198         #region SELECT
199 
200         #region  5.0 根據條件查詢 + List<TEntity> GetListBy(Expression<Func<T, bool>> whereLambda)
201         /// <summary>
202         /// 5.0 根據條件查詢
203         /// </summary>
204         /// <param name="whereLambda"></param>
205         /// <returns></returns>
206         public async Task<List<TEntity>> GetListBy(Expression<Func<TEntity, bool>> whereLambda)
207         {
208             return await _db.Set<TEntity>().Where(whereLambda).AsNoTracking().ToListAsync();
209         }
210 
211         public async Task<TEntity> GetModelById(Expression<Func<TEntity, bool>> whereLambda)
212         {
213             return await _db.Set<TEntity>().Where(whereLambda).AsNoTracking().FirstOrDefaultAsync();
214         }
215         public async Task<List<TEntity>> GetList()
216         {
217             return await _db.Set<TEntity>().AsNoTracking().ToListAsync();
218         }
219         #endregion
220 
221         #region 5.1 根據條件查詢，併排序 +  List<TEntity> GetListBy<TKey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
222         /// <summary>
223         /// 5.1 根據條件查詢，併排序
224         /// </summary>
225         /// <typeparam name="TKey"></typeparam>
226         /// <param name="whereLambda"></param>
227         /// <param name="orderLambda"></param>
228         /// <param name="isAsc"></param>
229         /// <returns></returns>
230         public async Task<List<TEntity>> GetListBy<TKey>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true)
231         {
232             if (isAsc)
233             {
234                 return await _db.Set<TEntity>().Where(whereLambda).OrderBy(orderLambda).AsNoTracking().ToListAsync();
235             }
236             else
237             {
238                 return await _db.Set<TEntity>().Where(whereLambda).OrderByDescending(orderLambda).AsNoTracking().ToListAsync();
239             }
240         }
241         #endregion
242 
243         #region 5.2 根據條件查詢Top多少個，併排序 + List<TEntity> GetListBy<TKey>(int top, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
244         /// <summary>
245         /// 5.2 根據條件查詢Top多少個，併排序
246         /// </summary>
247         /// <typeparam name="TKey"></typeparam>
248         /// <param name="top"></param>
249         /// <param name="whereLambda"></param>
250         /// <param name="orderLambda"></param>
251         /// <param name="isAsc"></param>
252         /// <returns></returns>
253         public async Task<List<TEntity>> GetListBy<TKey>(int top, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true)
254         {
255             if (isAsc)
256             {
257                 return await _db.Set<TEntity>().Where(whereLambda).OrderBy(orderLambda).Take(top).AsNoTracking().ToListAsync();
258             }
259             else
260             {
261                 return await _db.Set<TEntity>().Where(whereLambda).OrderByDescending(orderLambda).Take(top).AsNoTracking().ToListAsync();
262             }
263         }
264         #endregion
265 
266         #region  5.3 根據條件排序查詢  雙排序 + List<TEntity> GetListBy<TKey1, TKey2>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey1>> orderLambda1, Expression<Func<T, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
267         /// <summary>
268         /// 5.3 根據條件排序查詢  雙排序
269         /// </summary>
270         /// <typeparam name="TKey1"></typeparam>
271         /// <typeparam name="TKey2"></typeparam>
272         /// <param name="whereLambda"></param>
273         /// <param name="orderLambda1"></param>
274         /// <param name="orderLambda2"></param>
275         /// <param name="isAsc1"></param>
276         /// <param name="isAsc2"></param>
277         /// <returns></returns>
278         public async Task<List<TEntity>> GetListBy<TKey1, TKey2>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey1>> orderLambda1, Expression<Func<TEntity, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
279         {
280             if (isAsc1)
281             {
282                 if (isAsc2)
283                 {
284                     return await _db.Set<TEntity>().Where(whereLambda).OrderBy(orderLambda1).ThenBy(orderLambda2).AsNoTracking().ToListAsync();
285                 }
286                 else
287                 {
288                     return await _db.Set<TEntity>().Where(whereLambda).OrderBy(orderLambda1).ThenByDescending(orderLambda2).AsNoTracking().ToListAsync();
289                 }
290             }
291             else
292             {
293                 if (isAsc2)
294                 {
295                     return await _db.Set<TEntity>().Where(whereLambda).OrderByDescending(orderLambda1).ThenBy(orderLambda2).AsNoTracking().ToListAsync();
296                 }
297                 else
298                 {
299                     return await _db.Set<TEntity>().Where(whereLambda).OrderByDescending(orderLambda1).ThenByDescending(orderLambda2).AsNoTracking().ToListAsync();
300                 }
301             }
302         }
303         #endregion
304 
305         #region 5.3 根據條件排序查詢Top個數  雙排序 + List<TEntity> GetListBy<TKey1, TKey2>(int top, Expression<Func<T, bool>> whereLambda, System.Linq.Expressions.Expression<Func<T, TKey1>> orderLambda1, Expression<Func<T, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
306         /// <summary>
307         ///  5.3 根據條件排序查詢Top個數  雙排序
308         /// </summary>
309         /// <typeparam name="TKey1"></typeparam>
310         /// <typeparam name="TKey2"></typeparam>
311         /// <param name="top"></param>
312         /// <param name="whereLambda"></param>
313         /// <param name="orderLambda1"></param>
314         /// <param name="orderLambda2"></param>
315         /// <param name="isAsc1"></param>
316         /// <param name="isAsc2"></param>
317         /// <returns></returns>
318         public async Task<List<TEntity>> GetListBy<TKey1, TKey2>(int top, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey1>> orderLambda1, Expression<Func<TEntity, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
319         {
320             if (isAsc1)
321             {
322                 if (isAsc2)
323                 {
324                     return await _db.Set<TEntity>().Where(whereLambda).OrderBy(orderLambda1).ThenBy(orderLambda2).Take(top).AsNoTracking().ToListAsync();
325                 }
326                 else
327                 {
328                     return await _db.Set<TEntity>().Where(whereLambda).OrderBy(orderLambda1).ThenByDescending(orderLambda2).Take(top).AsNoTracking().ToListAsync();
329                 }
330             }
331             else
332             {
333                 if (isAsc2)
334                 {
335                     return await _db.Set<TEntity>().Where(whereLambda).OrderByDescending(orderLambda1).ThenBy(orderLambda2).Take(top).AsNoTracking().ToListAsync();
336                 }
337                 else
338                 {
339                     return await _db.Set<TEntity>().Where(whereLambda).OrderByDescending(orderLambda1).ThenByDescending(orderLambda2).Take(top).AsNoTracking().ToListAsync();
340                 }
341             }
342         }
343         #endregion
344 
345         #endregion SELECT
346 
347         #region 分頁
348 
349         #region 6.0 分頁查詢 + List<T> GetPagedList<TKey>
350         /// <summary>
351         /// 分頁查詢 + List<TEntity> GetPagedList
352         /// </summary>
353         /// <typeparam name="TKey"></typeparam>
354         /// <param name="pageIndex">頁碼</param>
355         /// <param name="pageSize">頁容量</param>
356         /// <param name="whereLambda">條件 lambda表達式
您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • C# in 參數修飾符
    in 修飾符記錄： 新版C# 新增加的 in 修飾符：保證發送到方法當中的數據不被更改（值類型），當in 修飾符用於引用類型時，可以改變變數的內容，單不能更改變數本身。 個人理解：in 修飾符傳遞的數據，在方法里就是只讀的 ，不能進行任何更改。 ...
  • 自己網站的搭建（少圖）
    從註冊而來的這麼多天，不對，是這麼多月以來，還沒有正經地寫過一篇博客，不對，連不正經的博客也沒有，正好有人邀請我一起搭建網站，看了下視頻覺得還可以，就開始動手了。 以前覺得搭網站，說難不難，可是說簡單又不簡單。 百度了一下，先自行總結了這麼幾步。 哦對，先把自己的網站放上來。 smallblog.x ...
  • 瞎折騰實錄：構建 Armel 版本的 .NET Core 教程和資料資源
    [TOC] 首先我要說明，我失敗了~ 我把我的進度和經驗放出來，希望能夠幫助別人完成編譯工作~ 背景：最近接手一個華為某型號的嵌入式設備，需要在上面搭建 .NET Core 環境。 設備是 Armel 架構的，Linux 內核 3.10；.NET Core ARM 只有 Armhf。 因此編譯出來的 ...
  • 1、MVC如何實例化控制器？
    我們知道MVC請求進來，然後路由匹配，然後找到控制器和Action，最後會調用Action方法，但是大家想想控制器是個普通的類，Action是個普通的實例方法，要想調用Action必須先實例化控制器，那麼MVC中如何實例化控制器的呢？ 1、MVC請求進來會先進入到UrlRoutingHandler里 ...
  • （四十九）c#Winform自定義控制項-下拉框（表格）
    前提 入行已經7,8年了，一直想做一套漂亮點的自定義控制項，於是就有了本系列文章。 GitHub：https://github.com/kwwwvagaa/NetWinformControl 碼雲：https://gitee.com/kwwwvagaa/net_winform_custom_contr ...
  • 第五章 函數day2
    5.2函數小高級 5.2.1 函數當參數 1 函數也可以當返回值 練習 函數其實也是一種數據類型，可以當變數存儲 面試題 5.2.2 閉包 閉包的意義： 返回的函數對象，不僅僅是一個函數對象，在該函數外還包裹了一層作用域，這使得，該函數無論在何處調用，優先使用自己外層包裹的作用域 閉包 就是在內層函 ...
  • WinForm任務欄最小化
    WinForm任務欄最小化 在C#編寫的WinForm里，在FormBorderStyle設為None的時候，任務欄點擊程式圖標，不會自動最小化。在主視窗WinForm.cs裡加入如下代碼後，即可恢復該功能。 protected override CreateParams CreateParams ...
  • WInform中實現設置ZedGraph中曲線的X軸與Y軸的上限與下限
    場景 Winforn中設置ZedGraph曲線圖的屬性、坐標軸屬性、刻度屬性： https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/100112573 在上面實現曲線相關屬性的設置的基礎上，要能修改曲線圖的X軸以及Y軸的上限和下限。 效 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類