.Net 5 简单实现消息订阅和事件总线

　　同样分两步走：先实现消息订阅和发布功能。相关概念我就不说了，Baidu一大堆。

先定义一下事件必须继承的接口：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Syspetro.Core.PubSub
{
    /// <summary>
    /// 事件处理器接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IEventHandler<T> where T : IEventBase
    {
        T DataSource { get; set; }
        bool Run();
        Task<bool> RunAsync();
        bool Callback();
    }
}

有了事件，是不是还需要给事件提供参数呢（消息）？接下来定义消息基类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using Syspetro.Core.ErrorException;

namespace Syspetro.Core.PubSub
{
    public interface IEventBase
    {
        /// <summary>
        /// 事件发生的时间
        /// </summary>
        DateTime EventTime { get; set; }
        /// <summary>
        /// 等待时间
        /// </summary>
        int WaitingTime { get; set; }
        /// <summary>
        /// 重试次数
        /// </summary>
        int Retry { get; set; }
        /// <summary>
        /// 执行结束标志
        /// </summary>
        bool Finished { get; set; }
        /// <summary>
        /// 等待执行结果返回
        /// </summary>
        void Awaiting();
    }

    /// <summary>
    /// 事件源
    /// </summary>
    public interface IEventData<T> : IEventBase
    {
        /// <summary>
        /// 触发事件需要的输入参数
        /// </summary>
        T EventSource { get; set; }
    }
    /// <summary>
    /// 此处有点粗糙了，有待优化
    /// </summary>
    public class EventBase : IEventBase
    {
        public DateTime EventTime { get; set; } = DateTime.Now;
        public int WaitingTime { get; set; } = 0;
        public int Retry { get; set; } = 0;
        public bool Finished { get; set; } = false;
        public void Awaiting()
        {
            if (WaitingTime > 0)
            {
                var oneTime = 0.2;
                var _WaitingTime = WaitingTime - oneTime;
                while (_WaitingTime > 0)
                {
                    Thread.Sleep((int)(oneTime * 1000));
                    _WaitingTime -= oneTime;
                    if (_WaitingTime <= 0 && !Finished) throw new ExceptionTimeOut();
                    if (Finished) _WaitingTime = 0;
                }
            }
        }
    }
}

下面实现的功能就是订阅消息和发布事件了：

using Microsoft.Extensions.Logging;
using Syspetro.Core.Extensions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace Syspetro.Core.PubSub
{
    /// <summary>
    /// 事件处理器容器
    /// </summary>
    public sealed class EventHandlerContainer
    {
        private readonly IServiceProvider _serviceProvider;
        private readonly Dictionary<string, List<Type>> _mappings = new Dictionary<string, List<Type>>();
        public EventHandlerContainer()
        {
            _serviceProvider = InternalApp.ServicesProvider;
        }
        public static string GetEventKey(Type type, string group)
        {
            return type.Name + "_" + group;
        }
        public static string GetEventGroup(string key)
        {
            var keys = key.Split("_");
            if (keys.Length >= 2)
                return keys[keys.Length-1];
            return null;
        }
        /// <summary>
        /// 订阅事件
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="THandler"></typeparam>
        /// <param name="group"></param>
        public void Subscribe<T, THandler>(string group = null) where T : IEventBase where THandler : IEventHandler<T>
        {
            var name = GetEventKey(typeof(T), group);
            if (!_mappings.ContainsKey(name))
            {
                _mappings.Add(name, new List<Type> { });
            }
            _mappings[name].Add(typeof(THandler));
        }
        /// <summary>
        /// 取消订阅事件
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="THandler"></typeparam>
        public void Unsubscribe<T, THandler>(string group = null) where T : IEventBase where THandler : IEventHandler<T>
        {
            var name = GetEventKey(typeof(T), group);
            _mappings[name].Remove(typeof(THandler));

            if (_mappings[name].Count == 0)
            {
                _mappings.Remove(name);
            }
        }
        #region 发布事件
        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="o"></param>
        /// <param name="group"></param>
        /// <returns></returns>
        public bool Publish<T>(T o, string group = null) where T : IEventBase
        {
            var name = GetEventKey(typeof(T), group);
            if (_mappings.ContainsKey(name))
            {
                try
                {
                    foreach (var handler in _mappings[name])
                    {
                        var bl = false;
                        var service = _serviceProvider.GetService(handler);
                        var _service = (IEventHandler<T>)service;
                        _service.DataSource = o;
                        bl = _service.Run();
                        if (bl) _service.Callback();
                        o.Finished = true;
                        return bl;
                    }
                }
                catch (Exception ex)
                {
                    InternalApp.CreatLogger("").LogError("发布事件失败", ex);
                    return false;
                }
                finally
                {
                    o.Finished = true;
                }
            }
            return false;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="o"></param>
        /// <param name="group"></param>
        /// <returns></returns>
        public async Task<bool> PublishAsync<T>(T o, string group) where T : IEventBase
        {
            var name = GetEventKey(typeof(T), group);
            if (_mappings.ContainsKey(name))
            {
                try
                {
                    foreach (var handler in _mappings[name])
                    {
                        var service = _serviceProvider.GetService(handler);
                        var _service = (IEventHandler<T>)service;
                        _service.DataSource = o;
                        var bl = await _service.RunAsync();
                        if (bl) _service.Callback();
                        o.Finished = true;
                        return bl;
                    }
                }
                catch (Exception ex)
                {
                    InternalApp.CreatLogger("").LogError("发布事件失败", ex);
                    return false;
                }
                finally
                {
                    o.Finished = true;
                }
            }
            return false;
        }
        #endregion
    }
}

到此就已经实现了消息订阅和发布，下面来看看事件总线，直接上代码吧：

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace Syspetro.Core.PubSub
{
    public class EventBus
    {
        private readonly EventHandlerContainer eventHandler = new EventHandlerContainer();
        private readonly object Lock = new object();
        private bool IsTrigger { get; set; } = false;
        /// <summary>
        /// 定义线程安全集合
        /// </summary>
        private readonly ConcurrentDictionary<string, List<IEventBase>> _eventAndHandlerMapping = new ConcurrentDictionary<string, List<IEventBase>>();
        public void Subscribe<T, THandler>(string group = null) where T : IEventBase where THandler : IEventHandler<T>
        {
            eventHandler.Subscribe<T, THandler>(group);
        }
        private void SetTrigger(bool bl)
        {
            lock (Lock)
            {
                IsTrigger = bl;
            }
        }
        /// <summary>
        /// 消息添加队列并尝试发布
        /// </summary>
        /// <typeparam name="TEventData"></typeparam>
        /// <param name="eventHandler"></param>
        /// <param name="group"></param>
        public void RegisterAsync<TEventData>(TEventData eventHandler, string group = null) where TEventData : IEventBase
        {
            var task = new Task(() =>
            {
                Register(eventHandler, group);
            });
            task.Start();
            return;
        }
        /// <summary>
        /// 消息添加队列并尝试发布
        /// </summary>
        /// <typeparam name="TEventData"></typeparam>
        /// <param name="eventHandler"></param>
        /// <param name="group"></param>
        public void Register<TEventData>(TEventData eventData, string group = null) where TEventData : IEventBase
        {
            if (!IsTrigger)
            {
                Trigger(eventData, group);
                NextTrigger();
            }
            else
            {
                var type = EventHandlerContainer.GetEventKey(typeof(TEventData), group);
                if (!_eventAndHandlerMapping.TryGetValue(type, out List<IEventBase> handlerTypes) || handlerTypes == null)
                {
                    handlerTypes = new List<IEventBase> { eventData };
                }
                else
                {
                    handlerTypes.Add(eventData);
                }
                _eventAndHandlerMapping[type] = handlerTypes;
                if (!IsTrigger) Trigger();
            }
        }
        /// <summary>
        /// 触发绑定的事件
        /// </summary>
        /// <param name="eventHandler"></param>
        public void Trigger()
        {
            if (!_eventAndHandlerMapping.IsEmpty)
            {
                Trigger(_eventAndHandlerMapping.Keys.First());
            }
        }
        /// <summary>
        /// 根据事件源类型触发绑定的事件处理
        /// </summary>
        /// <param name="eventHandler"></param>
        private void Trigger(string key)
        {
            try
            {
                if (_eventAndHandlerMapping.TryRemove(key, out List<IEventBase> events))
                {
                    if (!IsTrigger)
                    {
                        SetTrigger(true);
                    }
                    foreach (var e in events)
                    {
                        var group = EventHandlerContainer.GetEventGroup(key);
                        Trigger(e, group);
                    }
                }
            }
            finally
            {
                NextTrigger();
            }
        }
        /// <summary>
        /// 根据事件源触发绑定的事件处理
        /// </summary>
        /// <typeparam name="TEventData"></typeparam>
        /// <param name="eventData"></param>
        /// <param name="group"></param>
        private void Trigger<TEventData>(TEventData eventData, string group) where TEventData : IEventBase
        {
            int retry = eventData.Retry;
            if (!IsTrigger)
            {
                SetTrigger(true);
            }
            if (!eventHandler.Publish(eventData, group))
            {
                while (retry > 0)//重试
                {
                    if (eventHandler.Publish(eventData, group)) break;
                    retry--;
                }
            }
        }
        private void NextTrigger()
        {
            if (!_eventAndHandlerMapping.IsEmpty)
            {
                Trigger(_eventAndHandlerMapping.Keys.First());
            }
            else
            {
                SetTrigger(false);
            }
        }
    }
}

如何使用呢：

第一步是声明一个时间总线：

namespace Syspetro.Core.PubSub
{
    public  class EventSchedulerController
    {
        public static readonly EventBus DefaultBus = new EventBus();
    }
}

第二步定义自己的消息和事件如何执行：

using SP.ToolMatLabDomain.AlgCore;
using Syspetro.Core.PubSub;
using Syspetro.Deploy.Service;

namespace Sp.ToolMatLabScheduler.EventHandler
{
    public class test : EventDataBase
    {
        public test()
        {
            //this.WaitingTime = 10;
        }
    }
    public interface IFcc1T1EventHandler : ITransientService, IEventHandler<test>
    {

    }
    public class Fcc1T1EventHandler : EventHandlerBase<test>, IFcc1T1EventHandler
    {
        public override bool DoRun()
        {
            if (DataSource?.EventSource != null)//此处执行自己的业务逻辑
            {
                var db = DataSource.EventSource.Data2["_"];
                var calBack = Cal_Fcc1T1.Get(db);
                DataSource.OutPut = calBack.Item2;
                DataSource.Msg = calBack.Item1;
            }
            return false;
        }
    }
}

第三步：Startup中订阅消息

public void ConfigureServices(IServiceCollection services)
        {
//方式1：按消息类型发布
            EventSchedulerController.DefaultBus.Subscribe<test, IFcc1T1EventHandler>();

//方式2：相同消息分组分子发布
            EventSchedulerController.DefaultBus.Subscribe<EventDataBase, IFcc1T3EventHandler>("Fcc1T3");
            EventSchedulerController.DefaultBus.Subscribe<EventDataBase, IFcc1T4EventHandler>("Fcc1T4");
            EventSchedulerController.DefaultBus.Subscribe<EventDataBase, IFcc2EventHandler>("Fcc2");
        }

第四步：如何触发事件呢（发布消息）

using Microsoft.AspNetCore.Mvc;
using Sp.ToolMatLabScheduler;
using Sp.ToolMatLabScheduler.EventHandler;
using Syspetro.Core.AppDeal;
using Syspetro.Core.DynamicApi;
using Syspetro.Core.PubSub;
using Syspetro.Entity;
using System;
using System.Collections.Generic;
using System.Reflection;

namespace SP.ToolMatLabApp
{
    public class ServiceApp : BaseDynamicApi
    {
        [HttpPost]
        public SpActionResult<MatLabRes> test([FromBody] MatLabRep param)
        {
            if (param == null)
                return new SpActionResult<MatLabRes>() { Result = false, Msg = "参数不可为空" };
            return CalEventScheduler(new test { EventSource = param }, null);
        }
        [HttpPost]
        public SpActionResult<MatLabRes> Cal([FromBody] MatLabRep param)
        {
            if (param == null)
                return new SpActionResult<MatLabRes>() { Result = false, Msg = "参数不可为空" };
            return CalEventScheduler(new EventDataBase { EventSource = param }, param.CalName);
        }
        private SpActionResult<MatLabRes> CalEventScheduler(EventDataBase param, string group)
        {
            try
            {
                if (param.EventSource != null)
                {
                    EventSchedulerController.DefaultBus.RegisterAsync(param, group);

                    param.Awaiting();
                    var ret = new MatLabRes() { Datas = param.OutPut, Msg = param.Msg };
                    return new SpActionResult<MatLabRes>() { Data = ret };

                }
                else
                {
                    return new SpActionResult<MatLabRes>()
                    {
                        Msg = "计算出错了",
                        Result = false
                    };
                }
            }
            catch (Exception ex)
            {
                return new SpActionResult<MatLabRes>()
                {
                    Msg = ex.Message,
                    Result = false
                };
            }
        }
    }
}