基於rabbitmq的事件匯流排

来源:https://www.cnblogs.com/MrHanBlog/archive/2020/07/17/13330679.html
-Advertisement-
Play Games

在這個微服務火熱的時代，如果不懂一點微服務相關的技術，想吹下牛都沒有法子。於是有必要瞭解學習一下。所以我最近看了下微服務相關的知識。微服務所涉及的知識是很廣的，我這裡只是講一下事件匯流排，當然，有現成很棒的框架如CAP，但是我這裡只是為了去體驗去更深入的瞭解事件匯流排，去瞭解它的工作流程，所以我自己寫了 ...


       在這個微服務火熱的時代，如果不懂一點微服務相關的技術，想吹下牛都沒有法子。於是有必要瞭解學習一下。所以我最近看了下微服務相關的知識。
微服務所涉及的知識是很廣的，我這裡只是講一下事件匯流排，當然，有現成很棒的框架如CAP，但是我這裡只是為了去體驗去更深入的瞭解事件匯流排，去瞭解它的工作流程，所以我自己寫了一個基於RabbitMQ的事件匯流排。
1，運行rabbitmq；
2，創建解決方案，模擬分散式如下圖（我這裡之前學下了一下微服務的網關，所以會有Gateway，所以要運行3個程式，並且運行Consul做服務發現）：
 
3，實現api1的發佈功能：
     1，創建IEventBus作為抽象介面，實際上你可以用多個MQ來實現它，我這裡只是使用RabbitMQ，所以建一個EventBusRabbitMQ來實現介面

 public interface IEventBus
    {
    }
   public class EventBusRabbitMQ : IEventBus
    {
    }

 

 
     2，然後新建一個類，用來實現事件匯流排的DI註入：

serviceDescriptors.AddTransient<IEventBus, EventBusRabbitMQ>();

     3，發佈消息，為了能夠讓不同的服務都這個消息類型，並且可以使其作為參數傳遞，所以我們需要一個基類作為消息的匯流排：EventData，然後我們服務定義的每一個消息類型都必須繼承這個類：

 public class CreateUserEvent : EventData
    {
        public string Name { get; set; }
        public string Address { get; set; }
        public DateTime CreateTime { get; set; }

    }

 

      既然有消息那就會有消息事件，還需要一個EventHandler來驅動，所以每個服務的消息對象都應該有一個事件驅動的類，當然這個驅動類應該在訂閱方，應為發佈方只負責發佈消息，至於消息的處理事件則應該由訂閱方實現，下麵再講。其中消息的發佈是基於rabbitmq，網上有很多實現的例子，這裡只是我的寫法，以EventData作為參數：

 public void Publish(EventData eventData)
        {
            string routeKey = eventData.GetType().Name;
            channel.QueueDeclare(queueName, true, false, false, null);
            string message = JsonConvert.SerializeObject(eventData);
            byte[] body = Encoding.UTF8.GetBytes(message);
            channel.BasicPublish(exchangeName, routeKey, null, body);
        }

 

    然後訪問apil來模擬消息發佈：

 [HttpGet]
        [Route("api/user/eventbus")]
        public IActionResult Eventbus()
        {
            CreateUserEvent user = new CreateUserEvent();
            user.Name = "hanh";
            user.Address = "hubei";
            user.CreateTime = DateTime.Now;
            _eventBus.Publish(user);
            return Ok("ok");
        }

 

4，實現api2的訂閱功能
       剛已經將了訂閱應該會實現消息的事件處理，那麼就會有UserEventHandler，繼承EventHandler，來處理消息：

 public class UserEventHandler : IEventHandler<CreateUserEvent>, IEventHandler<UpdateUserEvent>
    {
        private readonly ILogger<UserEventHandler> _logger;
        public UserEventHandler(ILogger<UserEventHandler> logger)
        {
            _logger = logger;
        }
        public async Task Handler(CreateUserEvent eventData)
        {
            _logger.LogInformation(JsonConvert.SerializeObject(eventData));
             await Task.FromResult(0);
        }

        public async Task Handler(UpdateUserEvent eventData)
        {
            await Task.FromResult(0);
        }

    }

 

     然後會開始處理訂閱，大致的思路就是根據EventData作為key，然後每個EventData都應該有一個泛型的EventHandler<>介面，然後將其作為value存入記憶體中，同時rabbitmq綁定消息隊列，當消息到達時，自動處理消息事件，獲取到發佈消息的類型名字，然後我們根據類型名字從內從中獲取到它的EventData的類型，接著再根據這個類型，通過.net core內置的IOC來獲取到它的實現類，每個EventData的類型會匹配到不同的EventHandler，所以會完成CRUD。至此，大致的訂閱已經實現了：

  public void AddSub<T, TH>()
             where T : EventData
             where TH : IEventHandler
        {
            Type eventDataType = typeof(T);
            Type handlerType = typeof(TH);
            if (!eventhandlers.ContainsKey(typeof(T)))
                eventhandlers.TryAdd(eventDataType, handlerType);
            if(!eventTypes.ContainsKey(eventDataType.Name))
                eventTypes.TryAdd(eventDataType.Name, eventDataType);
            if (assemblyTypes != null)
            {
               Type implementationType = assemblyTypes.FirstOrDefault(s => handlerType.IsAssignableFrom(s));
                if (implementationType == null)
                    throw new ArgumentNullException("未找到{0}的實現類", handlerType.FullName);
                _serviceDescriptors.AddTransient(handlerType, implementationType);
            }
        }
   public void Subscribe<T, TH>()
            where T : EventData
            where TH : IEventHandler
        {
            _eventBusManager.AddSub<T, TH>();
            channel.QueueBind(queueName, exchangeName, typeof(T).Name);
            channel.QueueDeclare(queueName, true, false, false, null);
            var consumer = new EventingBasicConsumer(channel);
            consumer.Received +=async (model, ea) =>
            {
                string eventName = ea.RoutingKey;
                byte[] resp = ea.Body.ToArray();
                string body = Encoding.UTF8.GetString(resp);
                _log.LogInformation(body);
                try
                {
                    Type eventType = _eventBusManager.FindEventType(eventName);
                    T eventData = (T)JsonConvert.DeserializeObject(body, eventType);
                    IEventHandler<T> eventHandler = _eventBusManager.FindHandlerType(eventType) as IEventHandler<T>;
                    await eventHandler.Handler(eventData);
                }
                catch (Exception ex)
                {
                    throw ex;
                }

            };
            channel.BasicConsume(queueName, true, consumer);
        }

 

5，測試，訪問api1，發佈成功，然後api2會同時列印出信息：



最後給大家貼出核心代碼，如果想看完整的請訪問地址 https://github.com/Hansdas/Micro
 

using Micro.Core.EventBus.RabbitMQ;
using System;
using System.Collections.Generic;
using System.Text;

namespace Micro.Core.EventBus
{
    public interface IEventBus
    {
        /// <summary>
        /// 發佈
        /// </summary>
        /// <param name="eventData"></param>
        void Publish(EventData eventData);
        /// <summary>
        /// 訂閱
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="TH"></typeparam>
        void Subscribe<T, TH>()
            where T : EventData
            where TH : IEventHandler;
        /// <summary>
        /// 取消訂閱
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="TH"></typeparam>
        void Unsubscribe<T, TH>()
             where T : EventData
             where TH : IEventHandler;
    }
}

 


    

using log4net;
using Micro.Core.EventBus.RabbitMQ.IImplementation;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;

namespace Micro.Core.EventBus.RabbitMQ
{
    public class EventBusRabbitMQ : IEventBus
    {
        /// <summary>
        /// 隊列名稱
        /// </summary>
        private string queueName = "QUEUE";
        /// <summary>
        /// 交換機名稱
        /// </summary>
        private string exchangeName = "directName";
        /// <summary>
        /// 交換類型
        /// </summary>
        private string exchangeType = "direct";
        private IFactoryRabbitMQ _factory;
        private IEventBusManager _eventBusManager;
        private ILogger<EventBusRabbitMQ> _log;
        private readonly IConnection connection;
        private readonly IModel channel;
        public EventBusRabbitMQ(IFactoryRabbitMQ factory, IEventBusManager eventBusManager, ILogger<EventBusRabbitMQ> log)
        {
            _factory = factory;
            _eventBusManager = eventBusManager;
            _eventBusManager.OnRemoveEventHandler += OnRemoveEvent;
            _log = log;
            connection = _factory.CreateConnection();
            channel = connection.CreateModel();
        }
        private void OnRemoveEvent(object sender, ValueTuple<Type, Type> args)
        {
            channel.QueueUnbind(queueName, exchangeName, args.Item1.Name);
        }
        public void Publish(EventData eventData)
        {
            string routeKey = eventData.GetType().Name;
            channel.QueueDeclare(queueName, true, false, false, null);
            string message = JsonConvert.SerializeObject(eventData);
            byte[] body = Encoding.UTF8.GetBytes(message);
            channel.BasicPublish(exchangeName, routeKey, null, body);
        }

        public void Subscribe<T, TH>()
            where T : EventData
            where TH : IEventHandler
        {
            _eventBusManager.AddSub<T, TH>();
            channel.QueueBind(queueName, exchangeName, typeof(T).Name);
            channel.QueueDeclare(queueName, true, false, false, null);
            var consumer = new EventingBasicConsumer(channel);
            consumer.Received +=async (model, ea) =>
            {
                string eventName = ea.RoutingKey;
                byte[] resp = ea.Body.ToArray();
                string body = Encoding.UTF8.GetString(resp);
                _log.LogInformation(body);
                try
                {
                    Type eventType = _eventBusManager.FindEventType(eventName);
                    T eventData = (T)JsonConvert.DeserializeObject(body, eventType);
                    IEventHandler<T> eventHandler = _eventBusManager.FindHandlerType(eventType) as IEventHandler<T>;
                    await eventHandler.Handler(eventData);
                }
                catch (Exception ex)
                {
                    throw ex;
                }

            };
            channel.BasicConsume(queueName, true, consumer);
        }

        public void Unsubscribe<T, TH>()
           where T : EventData
           where TH : IEventHandler
        {
            if (_eventBusManager.HaveAddHandler(typeof(T)))
            {
                _eventBusManager.RemoveEventSub<T, TH>();
            }
        }
    }
}

 

using System;
using System.Collections.Generic;
using System.Text;

namespace Micro.Core.EventBus
{
    public interface IEventBusManager
    {
        /// <summary>
        /// 取消訂閱事件
        /// </summary>
        event EventHandler<ValueTuple<Type, Type>> OnRemoveEventHandler;
        /// <summary>
        /// 訂閱
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="TH"></typeparam>
        void AddSub<T, TH>()
            where T : EventData
            where TH : IEventHandler;
        /// <summary>
        /// 取消訂閱
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="TH"></typeparam>
        void RemoveEventSub<T, TH>()
            where T : EventData
            where TH : IEventHandler;
        /// <summary>
        /// 是否包含實體類型
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        bool HaveAddHandler(Type eventDataType);
        /// <summary>
        /// 根據實體名稱尋找類型
        /// </summary>
        /// <param name="eventName"></param>
        /// <returns></returns>
        Type FindEventType(string eventName);
        /// <summary>
        /// 根據實體類型尋找它的領域事件驅動
        /// </summary>
        /// <param name="eventDataType"></param>
        /// <returns></returns>
        object FindHandlerType(Type eventDataType);
    }
}

 

using Micro.Core.Configure;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;

namespace Micro.Core.EventBus
{
    internal class EventBusManager : IEventBusManager
    {
        public event EventHandler<ValueTuple<Type, Type>> OnRemoveEventHandler;
        private static ConcurrentDictionary<Type, Type> eventhandlers=new ConcurrentDictionary<Type, Type>();
        private readonly ConcurrentDictionary<string, Type> eventTypes = new ConcurrentDictionary<string, Type>();
        private readonly IList<Type> assemblyTypes;
        private readonly IServiceCollection _serviceDescriptors;
        private Func<IServiceCollection, IServiceProvider> _buildServiceProvider;
        public EventBusManager(IServiceCollection serviceDescriptors,Func<IServiceCollection,IServiceProvider> buildServiceProvicer)
        {
            _serviceDescriptors = serviceDescriptors;
            _buildServiceProvider = buildServiceProvicer;
            string dllName = ConfigurationProvider.configuration.GetSection("EventHandler.DLL").Value;
            if (!string.IsNullOrEmpty(dllName))
            {
                assemblyTypes = Assembly.Load(dllName).GetTypes();
            }
        }
        private void OnRemoveEvent(Type eventDataType, Type handler)
        {
            if (OnRemoveEventHandler != null)
            {
                OnRemoveEventHandler(this, new ValueTuple<Type, Type>(eventDataType, handler));
            }
        }
        public void AddSub<T, TH>()
             where T : EventData
             where TH : IEventHandler
        {
            Type eventDataType = typeof(T);
            Type handlerType = typeof(TH);
            if (!eventhandlers.ContainsKey(typeof(T)))
                eventhandlers.TryAdd(eventDataType, handlerType);
            if(!eventTypes.ContainsKey(eventDataType.Name))
                eventTypes.TryAdd(eventDataType.Name, eventDataType);
            if (assemblyTypes != null)
            {
               Type implementationType = assemblyTypes.FirstOrDefault(s => handlerType.IsAssignableFrom(s));
                if (implementationType == null)
                    throw new ArgumentNullException("未找到{0}的實現類", handlerType.FullName);
                _serviceDescriptors.AddTransient(handlerType, implementationType);
            }
        }
        public void RemoveEventSub<T, TH>()
            where T : EventData
            where TH : IEventHandler
        {

            OnRemoveEvent(typeof(T), typeof(TH));
        }
        public bool HaveAddHandler(Type eventDataType)
        {
            if (eventhandlers.ContainsKey(eventDataType))
                return true;
            return false;
        }
        public Type FindEventType(string eventName)
        {
            if(!eventTypes.ContainsKey(eventName))
                throw new ArgumentException(string.Format("eventTypes不存在類名{0}的key", eventName));
            return eventTypes[eventName];
        }
        public object FindHandlerType(Type eventDataType)
        {
            if(!eventhandlers.ContainsKey(eventDataType))
                throw new ArgumentException(string.Format("eventhandlers不存在類型{0}的key", eventDataType.FullName));
           var obj = _buildServiceProvider(_serviceDescriptors).GetService(eventhandlers[eventDataType]);
            if (eventhandlers[eventDataType].IsAssignableFrom(obj.GetType()))
                return obj;
            return null;
        }
    }

}

 

using Micro.Core.Configure;                               
using Micro.Core.EventBus.RabbitMQ;
using Micro.Core.EventBus.RabbitMQ.IImplementation;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;

namespace Micro.Core.EventBus
{
   public static class EventBusBuilder
    {
        public static EventBusOption eventBusOption;
        public static IServiceCollection AddEventBus(this IServiceCollection serviceDescriptors)
        {
            eventBusOption= ConfigurationProvider.GetModel<EventBusOption>("EventBusOption");
            switch (eventBusOption.MQProvider)
            {
                case MQProvider.RabbitMQ:
                    serviceDescriptors.AddTransient<IEventBus, EventBusRabbitMQ>();
                    serviceDescriptors.AddTransient(typeof(IFactoryRabbitMQ), factiory => {
                        return new FactoryRabbitMQ(eventBusOption);
                    });
                    break;
            }
            EventBusManager eventBusManager = new EventBusManager(serviceDescriptors,s=>s.BuildServiceProvider());
            serviceDescriptors.AddSingleton<IEventBusManager>(eventBusManager);
            return serviceDescriptors;
        }

    }
}

api1

 public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            services.AddEventBus();
        }
     
    }

 

api2:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Micro.Core.Configure;
using Micro.Core.Consul;
using Micro.Core.EventBus;
using Micro.Services.Domain;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using ConfigurationProvider = Micro.Core.Configure.ConfigurationProvider;

namespace WebApi3
{
    public class Startup
    {

        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            services.AddEventBus();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            var eventBus= app.ApplicationServices.GetRequiredService<IEventBus>();
            eventBus.Subscribe<CreateUserEvent, IEventHandler<CreateUserEvent>>();
            eventBus.Subscribe<UpdateUserEvent, IEventHandler<UpdateUserEvent>>();
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

        }
    }
}

 

ps:取消訂閱還沒有試過，我看了好多人寫的取消訂閱的方法是基於事件的思想，我也理解不了為啥，因為我覺得直接定義一個方法去實現就好了。

 

轉自  天天博客，歡迎訪問


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

-Advertisement-
Play Games
更多相關文章
  • WindowsForm實現警告消息框
    警告消息框主要是用來向用戶戶展示諸如警告、異常、完成和提示消息。一般實現的效果就是從系統視窗右下角彈出，然後加上些簡單的顯示和消失的動畫。 ###創建警告框視窗 首先我們創建一個警告框視窗(Form)，將視窗設置為無邊框(FormBoderStyle=None)，添加上圖片和內容顯示控制項 創建好警告 ...
  • 面向對象23種設計模式系列（二）- 結構型設計模式
    本系列將和大家分享面向對象23種設計模式中常用的幾種設計模式，本章主要簡單介紹下結構型設計模式。 ...
  • MSIL入門（三）之流程式控制制
    前言 在C#中提供了一些關鍵字if、else、switch、for等，這些關鍵字為我們提供了應用程式的流程式控制制。後面幾個章節我們將看到的是流程式控制制在IL中的實現。 static void Main(string[] args) { var a = 1; if (a == 0) { Console.W ...
  • C# 各類文件擴展名
    .cs： 類模塊代碼文件。業務邏輯處理層的代碼。 .sln：解決方案文件，為解決方案資源管理器提供顯示管理文件的圖形介面所需的信息。 .csproj：項目文件，創建應用程式所需的引用、數據連接、文件夾和文件的信息。 .aspx：動態網頁尾碼（拓展:jsp，php）。（靜態網頁尾碼，如:html，sh ...
  • 《ASP.NET Core 開發實戰》 - 學習筆記
    《ASP.NET Core 開發實戰》 [作者] (意) Dino Esposito[譯者] (中) 趙利通[出版] 清華大學出版社[版次] 2019年07月 第1版[印次] 2019年12月 第2次 印刷[定價] 79.80元 【前言】 (PVI) ASP.NET Core 是 ASP.NET 開 ...
  • 根據反射，動態調用websever
    [WebMethod] public string index(string Action,string Message) { try { // 1. 使用 WebClient 下載 WSDL 信息。 WebClient web = new WebClient(); Stream stream = ...
  • 使用 EF Core 遷移功能來創建資料庫
    https://docs.microsoft.com/zh-cn/aspnet/core/tutorials/first-mvc-app/adding-model?view=aspnetcore-5.0&tabs=visual-studio 上邊為微軟的操作文檔,按操作我遇到了下麵這個問題 歐克,面 ...
  • 引用對象的指針傳遞
    引用對象的實例代表了一個記憶體指針。當修改引用對象的屬性時，記憶體里的信息會發生相應變化。如果引用對象被new，則代表了一個新的指針，此時產生的更改不會影響之前指針指向的對象了。 同理，下麵new之後，list里保存的仍是之前的指針，所以不會被影響 List<WalletBalanceDayRecord ...
一周排行
    -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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類