小白開學Asp.Net Core《二》

来源:https://www.cnblogs.com/haoxiaozhang/archive/2019/05/14/10861269.html
-Advertisement-
Play Games

小白開學Asp.Net Core《二》 ——數據倉儲層（Repositroy） 一、歷史現象 在後端開發中，資料庫操作是最頻繁的，每一個開發人員都會接觸，甚至不少開發人員每天的工作就是與資料庫打交道。所以可見資料庫操作是多長重要。 在現在的開發過程中，大多數開發人員只是以編寫SQL語句的方式操作數據 ...


小白開學Asp.Net Core《二》

　　——數據倉儲層（Repositroy）

一、歷史現象

　　在後端開發中，資料庫操作是最頻繁的，每一個開發人員都會接觸，甚至不少開發人員每天的工作就是與資料庫打交道。所以可見資料庫操作是多長重要。

　　在現在的開發過程中，大多數開發人員只是以編寫SQL語句的方式操作資料庫，這種方式是操作資料庫最原始的方式，簡單高效，但是在編寫SQL語句的過程中，極容易因粗心大意寫出BUG，這樣就會出現一種現象，開發人員面對一堆SQL語句的DEBUG，而且每次都需要開發人員自己去手寫SQL語句，其開發效率極低。不同的資料庫所需的SQL語句也還是有差異的，這就需要開發人員學習不同的資料庫SQL語法。而且在項目開發中難免會遇到更換資料庫的情況，這時還需要花費大量的精力去修改SQL語句。

二、數據倉儲層

　　由於以上缺點，所以倉儲層因此而生。

　　數據倉儲層主要是對資料庫操作CRUD的封裝。使開發人員進行CRUD只需要極為簡單的代碼即可完成。本層還提供了資料庫事務的支持，為資料庫操作提供必備的保障。使用本層提供的介面，無需關心具體的業務邏輯實現，哪怕更換資料庫，也無需更改業務邏輯代碼，只需要更改簡單的資料庫配置即可。總之，本層為開發人員對資料庫的操作提供了簡單高效的操作介面。


三、繼承關係圖

　　 （繼承圖） 

　　（介面定義）

 

 四、代碼實現

 　　

 1 #region Async
 2         /// <summary>
 3         /// 查詢所有數據(無分頁,請慎用)
 4         /// </summary>
 5         /// <returns></returns>
 6         Task<IEnumerable<T>> FindAllAsync();
 7 
 8         /// <summary>
 9         /// 根據條件查詢數據
10         /// </summary>
11         /// <param name="predicate">條件表達式樹</param>
12         /// <param name="orderBy">排序</param>
13         /// <returns>泛型實體集合</returns>
14         Task<IEnumerable<T>> FindListByClauseAsync(Expression<Func<T, bool>> predicate, string orderBy = "");
15 
16         Task<IEnumerable<T>> PageQueryAsync(Expression<Func<T, bool>> predicate, int skip = 0, int pageSize = 15, string orderBy = "");
17         Task<T> FindByClauseAsync(Expression<Func<T, bool>> predicate);
18         /// <summary>
19         /// 插入實體數據
20         /// </summary>
21         /// <param name="entity"></param>
22         /// <returns></returns>
23         Task<int> InsertAsync(T entity);
24         /// <summary>
25         /// 更新實體數據
26         /// </summary>
27         /// <param name="entity"></param>
28         /// <returns></returns>
29         Task<bool> UpdateAsync(T entity);
30         /// <summary>
31         /// DeleteAsync
32         /// </summary>
33         /// <param name="entity"></param>
34         /// <returns></returns>
35         Task<bool> DeleteAsync(T entity);
36         /// <summary>
37         /// DeleteAsync
38         /// </summary>
39         /// <param name="where">條件表達式</param>
40         /// <returns></returns>
41         Task<bool> DeleteAsync(Expression<Func<T, bool>> @where);
42         /// <summary>
43         /// DeleteByIdAsync
44         /// </summary>
45         /// <param name="id"></param>
46         /// <returns></returns>
47         Task<bool> DeleteByIdAsync(object id);
48         /// <summary>
49         /// DeleteByIdsAsync
50         /// </summary>
51         /// <param name="ids">ids</param>
52         /// <returns></returns>
53         Task<bool> DeleteByIdsAsync(object[] ids);
54         /// <summary>
55         /// InsertAsync
56         /// </summary>
57         /// <param name="t"></param>
58         /// <returns></returns>
59         Task<DbResult<Task<int>>> InsertAsync(List<T> t);
60         /// <summary>
61         /// DeleteByClauseAsync
62         /// </summary>
63         /// <param name="predicate"></param>
64         /// <returns></returns>
65         Task<int> DeleteByClauseAsync(Expression<Func<T, bool>> predicate);
66 
67         /// <summary>
68         /// 事務
69         /// </summary>
70         /// <param name="func"></param>
71         /// <returns></returns>
72         Task<DbResult<T>> UserTranAsync(Func<T> func);
73 
74         /// <summary>
75         /// 事務
76         /// </summary>
77         /// <param name="action"></param>
78         Task<DbResult<bool>> UserTranAsync(Action action);
79         #endregion

五、實現　

/// <summary>
    /// GenericRepositoryBase
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class GenericSqlSugarRepositoryBase<T> : ISqlSugarRepository<T> where T : class, new()
    {
        #region Sync
        /// <summary>
        /// 根據主鍵查詢
        /// </summary>
        /// <param name="pkValue">主鍵</param>
        /// <returns></returns>
        public T FindById(object pkValue)
        {
            using (var db = DbFactory.DB)
            {
                return db.Queryable<T>().InSingle(pkValue);
            }
        }

        /// <summary>
        /// 查詢所有數據(無分頁,請慎用)
        /// </summary>
        /// <returns></returns>
        public IEnumerable<T> FindAll()
        {
            using (var db = DbFactory.DB)
            {
                return db.Queryable<T>().ToList();
            }
        }

        /// <summary>
        /// 根據條件查詢數據
        /// </summary>
        /// <param name="predicate">條件表達式樹</param>
        /// <param name="orderBy">排序</param>
        /// <returns>泛型實體集合</returns>
        public IEnumerable<T> FindListByClause(Expression<Func<T, bool>> predicate, string orderBy = "")
        {
            using (var db = DbFactory.DB)
            {
                var query = db.Queryable<T>().Where(predicate);
                if (!string.IsNullOrEmpty(orderBy))
                    query.OrderBy(orderBy);
                return query.ToList();
            }
        }

        /// <summary>
        /// 根據條件分頁查詢
        /// </summary>
        /// <param name="predicate">條件表達式樹</param>
        /// <param name="skip"></param>
        /// <param name="pageSize"></param>
        /// <param name="orderBy"></param>
        /// <returns></returns>
        public IEnumerable<T> PageQuery(Expression<Func<T, bool>> predicate, int skip, int pageSize = 15,
            string orderBy = "")
        {
            using (var db = DbFactory.DB)
            {
                if (skip > 0)
                    skip = pageSize * skip;
                var query = db.Queryable<T>().Where(predicate).Skip(skip).Take(pageSize);
                if (!string.IsNullOrEmpty(orderBy))
                    query = query.OrderBy(orderBy);
                return query.ToList();
            }
        }

        /// <summary>
        /// 根據條件查詢數據
        /// </summary>
        /// <param name="predicate">條件表達式樹</param>
        /// <returns></returns>
        public T FindByClause(Expression<Func<T, bool>> predicate)
        {
            using (var db = DbFactory.DB)
            {
                return db.Queryable<T>().First(predicate);
            }
        }

        /// <summary>
        /// 寫入實體數據
        /// </summary>
        /// <param name="entity">實體類</param>
        /// <returns></returns>
        public int Insert(T entity)
        {
            using (var db = DbFactory.DB)
            {
                return db.Insertable(entity).ExecuteCommand();
            }
        }

        /// <summary>
        /// 更新實體數據
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public bool Update(T entity)
        {
            using (var db = DbFactory.DB)
            {
                return db.Updateable(entity).ExecuteCommand() > 0;
            }
        }

        /// <summary>
        /// 刪除數據
        /// </summary>
        /// <param name="entity">實體類</param>
        /// <returns></returns>
        public bool Delete(T entity)
        {
            using (var db = DbFactory.DB)
            {
                return db.Deleteable(entity).ExecuteCommand() > 0;
            }
        }

        /// <summary>
        /// 刪除數據
        /// </summary>
        /// <param name="where">過濾條件</param>
        /// <returns></returns>
        public bool Delete(Expression<Func<T, bool>> @where)
        {
            using (var db = DbFactory.DB)
            {
                return db.Deleteable<T>(@where).ExecuteCommand() > 0;
            }
        }

        /// <summary>
        /// 刪除指定ID的數據
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public bool DeleteById(object id)
        {
            using (var db = DbFactory.DB)
            {
                return db.Deleteable<T>(id).ExecuteCommand() > 0;
            }
        }

        /// <summary>
        /// 刪除指定ID集合的數據(批量刪除)
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        public bool DeleteByIds(object[] ids)
        {
            using (var db = DbFactory.DB)
            {
                return db.Deleteable<T>().In(ids).ExecuteCommand() > 0;
            }
        }

        /// <summary>
        /// 執行sql語句
        /// </summary>
        /// <param name="sql">sql 語句</param>
        /// <param name="parameters">參數</param>
        /// <returns></returns>
        public IEnumerable<T> FindListBySql(string sql, object dynamic)
        {
            using (var db = DbFactory.DB)
            {
                return db.Ado.SqlQuery<T>(sql, dynamic);
            }
        }

        /// <summary>
        /// 批量插入 插入失敗時 事務會自動回退
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public int Insert(List<T> t)
        {
            using (var db = DbFactory.DB)
            {
                return db.Ado.UseTran(() => db.Insertable(t.ToArray()).ExecuteCommand()).Data;
            }
        }

        /// <summary>
        /// 事務
        /// </summary>
        /// <param name="func"></param>
        /// <returns></returns>
        public DbResult<T> UserTran(Func<T> func)
        {
            using (var db = DbFactory.DB)
            {
                return db.Ado.UseTran(func.Invoke);
            }
        }

        /// <summary>
        /// 事務
        /// </summary>
        /// <param name="action"></param>
        public DbResult<bool> UserTran(Action action)
        {
            using (var db = DbFactory.DB)
            {
                return db.Ado.UseTran(action.Invoke);
            }
        }

        /// <summary>
        /// 根據條件批量刪除
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public int DeleteByClause(Expression<Func<T, bool>> predicate)
        {
            using (var db = DbFactory.DB)
            {
                return db.Deleteable<T>().Where(predicate).ExecuteCommand();
            }
        }

        // void ShadowCopy(object a, object b);

        /// <summary>
        /// 分頁查詢
        /// </summary>
        /// <param name="predicate"></param>
        /// <param name="pagination"></param>
        /// <returns></returns>
        public List<T> FindList(Expression<Func<T, bool>> predicate, Pagination pagination)
        {
            var isAsc = pagination.sord.ToLower() == "asc";
            string[] _order = pagination.sidx.Split(',');
            MethodCallExpression resultExp = null;
            using (var db = DbFactory.DB)
            {
                var tempData = db.Queryable<T>().Where(predicate).ToList().AsQueryable();
                foreach (string item in _order)
                {
                    string _orderPart = item;
                    _orderPart = Regex.Replace(_orderPart, @"\s+", " ");
                    string[] _orderArry = _orderPart.Split(' ');
                    string _orderField = _orderArry[0];
                    bool sort = isAsc;
                    if (_orderArry.Length == 2)
                    {
                        isAsc = _orderArry[1].ToUpper() == "ASC";
                    }
                    var parameter = Expression.Parameter(typeof(T), "t");
                    var property = typeof(T).GetProperty(_orderField);
                    var propertyAccess = Expression.MakeMemberAccess(parameter, property);
                    var orderByExp = Expression.Lambda(propertyAccess, parameter);
                    resultExp = Expression.Call(typeof(Queryable), isAsc ? "OrderBy" : "OrderByDescending", new Type[] { typeof(T), property.PropertyType }, tempData.Expression, Expression.Quote(orderByExp));
                }
                tempData = tempData.Provider.CreateQuery<T>(resultExp);
                pagination.records = tempData.Count();
                tempData = tempData.Skip<T>(pagination.rows * (pagination.page - 1)).Take<T>(pagination.rows).AsQueryable();
                return tempData.ToList();
            }
        }
        #endregion

        #region Async
        /// <summary>
        /// 查詢所有數據(無分頁,請慎用)
        /// </summary>
        /// <returns></returns>
        public async Task<IEnumerable<T>> FindAllAsync()
        {
            using (var db = DbFactory.DB)
            {
                return await db.Queryable<T>().ToListAsync();
            }
        }

        /// <summary>
        /// 根據條件查詢數據
        /// </summary>
        /// <param name="predicate">條件表達式樹</param>
        /// <param name="orderBy">排序</param>
        /// <returns>泛型實體集合</returns>
        public async Task<IEnumerable<T>> FindListByClauseAsync(Expression<Func<T, bool>> predicate, string orderBy = "")
        {
            using (var db = DbFactory.DB)
            {
                var query = db.Queryable<T>().Where(predicate);
                if (!string.IsNullOrEmpty(orderBy))
                {
                    query = query.OrderBy(orderBy);
                }
                return await query.ToListAsync();
            }
        }

        public async Task<IEnumerable<T>> PageQueryAsync(Expression<Func<T, bool>> predicate, int skip = 0,
            int pageSize = 15, string orderBy = "")
        {
            using (var db = DbFactory.DB)
            {
                if (skip > 0)
                    skip = pageSize * skip;
                var query = db.Queryable<T>().Where(predicate).Skip(skip).Take(pageSize);
                if (!string.IsNullOrEmpty(orderBy))
                {
                    query = query.OrderBy(orderBy);
                }
                return await query.ToListAsync();
            }
        }

        public async Task<T> FindByClauseAsync(Expression<Func<T, bool>> predicate)
        {
            using (var db = DbFactory.DB)
            {
                return await db.Queryable<T>().FirstAsync(predicate);
            }
        }

        /// <summary>
        /// 插入實體數據
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public async Task<int> InsertAsync(T entity)
        {
            using (var db = DbFactory.DB)
            {
                return await db.Insertable(entity).ExecuteCommandAsync();
            }
        }

        /// <summary>
        /// 更新實體數據
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public async Task<bool> UpdateAsync(T entity)
        {
            using (var db = DbFactory.DB)
            {
                return await db.Updateable(entity).ExecuteCommandAsync() > 0;
            }
        }

        /// <summary>
        /// DeleteAsync
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public async Task<bool> DeleteAsync(T entity)
        {
            using (var db = DbFactory.DB)
            {
                return await db.Deleteable(entity).ExecuteCommandAsync() > 0;
            }
        }

        /// <summary>
        /// DeleteAsync
        /// </summary>
        /// <param name="where">條件表達式</param>
        /// <returns></returns>
        public async Task<bool> DeleteAsync(Expression<Func<T, bool>> @where)
        {
            using (var db = DbFactory.DB)
            {
                return await db.Deleteable(@where).ExecuteCommandAsync() > 0;
            }
        }

        /// <summary>
        /// DeleteByIdAsync
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<bool> DeleteByIdAsync(object id)
        {
            using (var db = DbFactory.DB)
            {
                return await db.Deleteable<T>(id).ExecuteCommandAsync() > 0;
            }
        }

        /// <summary>
        /// DeleteByIdsAsync
        /// </summary>
        /// <param name="ids">ids</param>
        /// <returns></returns>
        public async Task<bool> DeleteByIdsAsync(object[] ids)
        {
            using (var db = DbFactory.DB)
            {
                return await db.Deleteable<T>().In(ids).ExecuteCommandAsync() > 0;
            }
        }

        /// <summary>
        /// InsertAsync
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public async Task<DbResult<Task<int>>> InsertAsync(List<T> t)
        {
            using (var db = DbFactory.DB)
            {
                return await db.Ado.UseTranAsync(async () => await db.Insertable(t.ToArray()).ExecuteCommandAsync());
            }
        }

        /// <summary>
        /// DeleteByClauseAsync
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public async Task<int> DeleteByClauseAsync(Expression<Func<T, bool>> predicate)
        {
            using (var db = DbFactory.DB)
            {
                return await db.Deleteable<T>().Where(predicate).ExecuteCommandAsync();
            }
        }

        /// <summary>
        /// 事務
        /// </summary>
        /// <param name="func"></param>
        /// <returns></returns>
        public async Task<DbResult<T>> UserTranAsync(Func<T> func)
        {
            using (var db = DbFactory.DB)
            {
                return await db.Ado.UseTranAsync(func.Invoke);
            }
        }

        /// <summary>
        /// 事務
        /// </summary>
        /// <param name="action"></param>
        public async Task<DbResult<bool>> UserTranAsync(Action action)
        {
            using (var db = DbFactory.DB)
            {
                return await db.Ado.UseTranAsync(action.Invoke);
            }
        }
        #endregion
    }

本篇就到這裡，下篇將介紹業務邏輯層與倉儲庫之間的關係與實現

 

（本人堅信：學習是由淺到深的過程，先打基礎）

　　不喜勿噴！謝謝！

GitHub地址：

　　https://github.com/AjuPrince/Aju.Carefree

 


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • .netcore2.1 JS-SDK 從後臺獲取微信簽名，實現自定義分享標題、描述、圖片
    最近項目移動端需要實現微信自定義分享功能，包含分享自定義標題、描述等。 首先到公眾號的後臺，功能設置裡面，添加將要被分享的功能變數名稱，如圖 後端簽名演算法實現 ，參考騰訊開發者文檔https://mp.weixin.qq.com/wiki?t=resource/res_main&id=mp142114111 ...
  • DSAPI CMD命令行進程代理
    DSAPI.文件.CMD命令行進程代理，是用來和CMD.exe或指定exe進行輸出重定向的簡化使用工具，可隱藏或顯式地啟動一個cmd.exe，並將輸出流、輸入流和錯誤流重定向至代理，通過事件觸發方式與之交互。 相關代碼如下： ...
  • UWP 推薦 - 限時免費的RSS閱讀器《RSS 追蹤》登錄 Windows 10
    文/雲之幻 前不久，博客作者 Bravo Yeung 寫了一篇還算略受歡迎的關於 RSS 的文章 ".Net開發者必知的技術類RSS訂閱指南" 。 RSS 現在用的人很少了，而且就算是我，也不過是在一周前才開始正視 RSS 。只因為接觸到了一個很好很強大的社區 RSS Hub ，當時看到之後就立刻做 ...
  • Echarts柱狀圖添加點擊事件
    Echarts基本顯示： var c1 = echarts.init(document.getElementById('pic_01')); var op1= { title : { text: '某地區蒸發量和降水量', subtext: '純屬虛構' }, tooltip : { trigger ...
  • 使用 ASP.NET Core MVC 創建 Web API——響應數據的內容協商（七）
    ASP.NET Core MVC 包含對通過固定格式或根據客戶端規範來設置響應數據格式的內置支持。 ASP.NET Web API的內容協商（Content Negotiation）機制的理想情況是這樣的：客戶端在請求頭的Accept欄位中指定什麼樣的MIME類型，Web API服務端就... ...
  • （1）Asp.Net Core應用啟動Startup類簡介
    1.前言 Core與早期版本的 ASP.NET 對比，配置應用程式的方式的 Global.asax、FilterConfig.cs和RouteConfig.cs 都被Program.cs 和 Startup.cs取代了。Program.cs作為Web應用程式的預設入口，在沒有任何修改的情況下，會調用 ...
  • [APB VNext 筆記] UI
    一直想給我做的服務寫UI。但苦於現在ABPVNext框架對SPA支持不好。只好先放棄VUE。先弄個UI在說。ABPVNext中的框架都是用Helper封裝好的Label。不知道怎麼使用，於是翻源代碼。找到了Demo。 Components Alerts Badges Borders Breadcru ...
  • 查找區配的訂單號
    剛剛有網友在QQ問及，根據訂單首碼，去查找與首碼匹配的訂單號。 Insus.NET在控制台應用程式中，使用普通的方法來實現，參考下麵代碼示例： using System; using System.Collections.Generic; using System.IO; using System. ...
一周排行
    -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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類