C#实现一个自己的事件总线EventBus框架

最新推荐文章于 2024-06-11 14:18:05 发布

slimewang

最新推荐文章于 2024-06-11 14:18:05 发布

阅读量1k

点赞数 11

文章标签： c# 开发语言

本文链接：https://blog.csdn.net/slimewang/article/details/134694622

版权

一.EventBus简介

事件总线（EventBus）用于在软件组件之间实现松耦合通信。它提供了一种分发、订阅的方式在应用程序内各个组件之间传递消息。而这些组件可以是对象、模块、模型、控制器等等。

事件总线的核心思想是发布者/订阅者模型。事件总线提供了一个中介的角色，使得发布者和订阅者不需要直接互相联系，而是将消息发布到事件总线，事件总线再将消息转发给所有订阅者。

事件总线可以用于实现解耦合的组件之间的通信，也可以用于实现模块化的设计，减少应用程序的复杂度，并提高代码的可维护性和可重用性。

1.此框架使用非常简便，可以在整个程序的任意地方使用静态的EventBus.Subscribe()函数进行订阅。使用静态的EventBus.Publish()函数进行发布。有参数类型和函数名两种方式进行关联。

2.支持多播。

3.支持订阅发布方式有同步无返回值，同步有返回值，异步无返回值，异步有返回值四种方式选择。

4.基于.netstandard2.0开发的，能够适配.Net几乎所有平台版本，不需要担心兼容性的问题。

二. 使用方式

1.下载Nuget包

直接在Nuget上搜索WdlEventBus就可找到，下载使用。

NuGet\Install-Package WdlEventBus -Version 2.0.1

GitHub地址：

https://github.com/Wangslime/WdlTool.git

2.使用案例

using WdlEventBus;应用类库之后就可以直接使用，调用静态的EventBus.Subscribe方法进行订阅。

using WdlEventBus;

namespace Test1
{
    public class Test
    {
        public Test()
        {
            //EventBus.Publish("OnAdd");
            EventBus.Subscribe(OnAdd);

            //EventBus.PublishResult("OnAddResult");
            EventBus.SubscribeResult(OnAddResult);

            //EventBus.PublishAsync("OnAddAsync");
            EventBus.SubscribeAsync(OnAddAsync);

            //EventBus.PublishResultAsync("OnAddResultAsync");
            EventBus.SubscribeResultAsync(OnAddResultAsync);


            //EventBus.Publish<string>("OnAdd");
            EventBus.Subscribe<string>(OnAdd);

            //EventBus.PublishResult<string>("OnAddResult");
            EventBus.SubscribeResult<string>(OnAddResult);

            //EventBus.PublishAsync<string>("OnAddAsync");
            EventBus.SubscribeAsync<string>(OnAddAsync);

            //EventBus.PublishResultAsync<string>("OnAddResultAsync");
            EventBus.SubscribeResultAsync<string>(OnAddResultAsync);
        }

        private void OnAdd(EventData<string> obj)
        {
            throw new NotImplementedException();
        }

        private object OnAddResult(EventData<string> arg)
        {
            throw new NotImplementedException();
        }

        private Task OnAddAsync(EventData<string> arg)
        {
            throw new NotImplementedException();
        }

        private Task<object> OnAddResultAsync(EventData<string> arg)
        {
            object result = arg;
            return Task.FromResult(result);
        }

        private Task<object> OnAddResultAsync(EventData arg)
        {
            object result = arg;
            return Task.FromResult(result);
        }

        private Task OnAddAsync(EventData arg)
        {
            throw new NotImplementedException();
        }

        private void OnAdd(EventData obj)
        {
            obj.MethodName = "hahaha";
            object result = obj;
        }
        private string OnAddResult(EventData obj)
        {
            obj.MethodName = "hahaha";
            return obj.MethodName;
        }
    }
}

调用静态的EventBus.Publish方法进行发布触发。上面的代码中EventBus.Publish注释部分就是对应的触发方法。

using Newtonsoft.Json;
using Test1;
using WdlEventBus;

namespace TestMain
{
    internal class Program
    {
        static async Task Main(string[] args)
        {
            new Test();
            while (true)
            {
                List<object> obj = await EventBus.PublishResultAsync("OnAddResultAsync");
                Console.WriteLine(JsonConvert.SerializeObject(obj.First()));
                Thread.Sleep(1000);
            }
        }
    }
}

三. 使用技术

单例模式

观察者模式

线程安全集合

委托

泛型

多态

五.代码实现

1. 参数定义

using System;

namespace WdlEventBus
{
    internal interface IEventData
    {

    }
    public class EventData : IEventData
    {
        public object Sender { get; set; }
        public DateTime EventTime { get; set; } = DateTime.Now;
        public string MethodName { get; set; } = "";
        public string EventName { get; set; } = "";
        public object Data { get; set; }
    }

    public class EventData<T> : IEventData
    {
        public object Sender { get; set; }
        public DateTime EventTime { get; set; } = DateTime.Now;
        public string MethodName { get; set; } = "";
        public string EventName { get; set; } = "";
        public T Data { get; set; }
    }
}

2. 事件管理

using System;
using System.Threading.Tasks;

namespace WdlEventBus
{
    internal class EventHander : IEventData
    {
        internal Action<EventData> action { get; set; } = null;

        internal Func<EventData, object> func { get; set; } = null;

        internal EventHander(Action<EventData> action, Func<EventData, object> func)
        {
            this.action = action;
            this.func = func;
        }
        internal void HandleEventViod(EventData eventData)
        {
            action.Invoke(eventData);
        }

        internal object HandleEventObj(EventData eventData)
        {
            return func.Invoke(eventData);
        }
    }

    internal class EventHanderAsync : IEventData
    {
        internal Func<EventData, Task<object>> func { get; set; } = null;
        internal Func<EventData, Task> funcVoid { get; set; } = null;
        internal EventHanderAsync(Func<EventData, Task> funcVoid, Func<EventData, Task<object>> func)
        {
            this.funcVoid = funcVoid;
            this.func = func;
        }

        internal Task<object> HandleEventObj(EventData eventData)
        {
            return func.Invoke(eventData);
        }

        internal Task HandleEventVoid(EventData eventData)
        {
            return funcVoid.Invoke(eventData);
        }
    }

    internal class EventHander<T> : IEventData
    {
        internal Action<EventData<T>> action { get; set; } = null;

        internal Func<EventData<T>, object> func { get; set; } = null;

        internal EventHander(Action<EventData<T>> action, Func<EventData<T>, object> func)
        {
            this.action = action;
            this.func = func;
        }
        internal void HandleEventAction(EventData<T> eventData)
        {
            action.Invoke(eventData);
        }

        internal object HandleEventFunc(EventData<T> eventData)
        {
            return func.Invoke(eventData);
        }
    }

    internal class EventHanderAsync<T> : IEventData
    {
        internal Func<EventData<T>, Task<object>> func { get; set; } = null;
        internal Func<EventData<T>, Task> funcVoid { get; set; } = null;
        internal EventHanderAsync(Func<EventData<T>, Task> funcVoid, Func<EventData<T>, Task<object>> func)
        {
            this.funcVoid = funcVoid;
            this.func = func;
        }

        internal Task<object> HandleEventObj(EventData<T> eventData)
        {
            return func.Invoke(eventData);
        }

        internal Task HandleEventVoid(EventData<T> eventData)
        {
            return funcVoid.Invoke(eventData);
        }
    }
}

3.代码主体，函数和逻辑管理

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

namespace WdlEventBus
{
    public class EventBus
    {
        #region 单例模式
        private static readonly object locked = new object();
        private static EventBus _Instance = new EventBus();
        public static EventBus Instance
        {
            get
            {
                if (_Instance == null)
                {
                    lock (locked)
                    {
                        if (_Instance == null)
                        {
                            _Instance = new EventBus();
                        }
                    }
                }
                return _Instance;
            }
            set
            {
                lock (locked)
                {
                    _Instance = value;
                }
            }
        }
        #endregion

        #region 泛型事件订阅执行集合
        /// <summary>
        /// 泛型事件集合
        /// </summary>
        private ConcurrentDictionary<Type, List<IEventData>> dicEventType = new ConcurrentDictionary<Type, List<IEventData>>();

        #region 订阅

        /// <summary>
        /// 同步订阅不带返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="action"></param>
        public static void Subscribe<T>(Action<EventData<T>> action)
        {
            IEventData eventHander = new EventHander<T>(action, null);
            Instance.PrivateSubscribe<T>(eventHander);
        }

        /// <summary>
        /// 同步订阅带返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="func"></param>
        public static void SubscribeResult<T>(Func<EventData<T>, object> func)
        {
            IEventData eventHander = new EventHander<T>(null, func);
            Instance.PrivateSubscribe<T>(eventHander);
        }

        /// <summary>
        /// 异步订阅不返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="func"></param>
        public static void SubscribeAsync<T>(Func<EventData<T>, Task> func)
        {
            IEventData eventHander = new EventHanderAsync<T>(func, null);
            Instance.PrivateSubscribe<T>(eventHander);
        }

        /// <summary>
        /// 异步订阅带返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="func"></param>
        public static void SubscribeResultAsync<T>(Func<EventData<T>, Task<object>> func)
        {
            IEventData eventHander = new EventHanderAsync<T>(null, func);
            Instance.PrivateSubscribe<T>(eventHander);
        }

        private void PrivateSubscribe<T>(IEventData eventData)
        {
            Type type = typeof(T);
            if (!dicEventType.ContainsKey(type))
            {
                dicEventType.TryAdd(type, new List<IEventData>());
            }
            if (dicEventType.TryGetValue(type, out var actionList))
            {
                if (actionList == null)
                {
                    actionList = new List<IEventData>();
                }
                actionList.Add(eventData);
            }
            else
            {
                throw new Exception($"订阅事件添加失败");
            }
        }
        #endregion

        #region 执行

        /// <summary>
        /// 同步执行不带返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="eventData"></param>
        public static void Publish<T>()
        {
            EventData<T> eventData = new EventData<T>();
            Publish(eventData);
        }
        public static void Publish<T>(string eventName)
        {
            EventData<T> eventData = new EventData<T>() {EventName = eventName };
            Publish(eventData);
        }
        public static void Publish<T>(T t)
        {
            EventData<T> eventData = new EventData<T>() { Data = t };
            Publish(eventData);
        }
        public static void Publish<T>(string eventName, T t)
        {
            EventData<T> eventData = new EventData<T>() { EventName = eventName, Data = t };
            Publish(eventData);
        }
        public static void Publish<T>(string methodName, string eventName)
        {
            EventData<T> eventData = new EventData<T>() { MethodName = methodName, EventName = eventName };
            Publish(eventData);
        }
        public static void Publish<T>(string methodName, string eventName, T t)
        {
            EventData<T> eventData = new EventData<T>() { MethodName = methodName, EventName = eventName, Data = t };
            Publish(eventData);
        }
        public static void Publish<T>(EventData<T> eventData)
        {
            Instance.PrivatePublish(eventData);
        }
        private void PrivatePublish<T>(EventData<T> eventData)
        {
            Type type = typeof(T);
            if (dicEventType.ContainsKey(type))
            {
                if (dicEventType.TryGetValue(type, out var actionList))
                {
                    if (actionList != null && actionList.Any())
                    {
                        foreach (var item in actionList)
                        {
                            if (item is EventHander<T>)
                            {
                                EventHander<T> eventHander = item as EventHander<T>;

                                if (eventHander != null && eventHander.action != null && (string.IsNullOrEmpty(eventData.MethodName) || eventHander.action.Method.Name == eventData.MethodName))
                                {
                                    eventHander.HandleEventAction(eventData);
                                }
                            }
                        }
                    }
                }
            }
        }


        /// <summary>
        /// 同步执行带返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="eventData"></param>
        /// <returns></returns>
        public static List<object> PublishResult<T>()
        {
            EventData<T> eventData = new EventData<T>();
            return PublishResult(eventData);
        }
        public static List<object> PublishResult<T>(string eventName)
        {
            EventData<T> eventData = new EventData<T>() { EventName = eventName };
            return PublishResult(eventData);
        }
        public static List<object> PublishResult<T>(T t)
        {
            EventData<T> eventData = new EventData<T>() { Data = t };
            return PublishResult(eventData);
        }
        public static List<object> PublishResult<T>(string eventName, T t)
        {
            EventData<T> eventData = new EventData<T>() { EventName = eventName, Data = t };
            return PublishResult(eventData);
        }
        public static List<object> PublishResult<T>(string methodName, string eventName)
        {
            EventData<T> eventData = new EventData<T>() { MethodName = methodName, EventName = eventName };
            return PublishResult(eventData);
        }
        public static List<object> PublishResult<T>(string methodName, string eventName, T t)
        {
            EventData<T> eventData = new EventData<T>() { MethodName = methodName, EventName = eventName, Data = t };
            return PublishResult(eventData);
        }
        public static List<object> PublishResult<T>(EventData<T> eventData)
        {
            return Instance.PrivatePublishResult(eventData);
        }
        private List<object> PrivatePublishResult<T>(EventData<T> eventData)
        {
            List<object> list = new List<object>();
            Type type = typeof(T);
            if (dicEventType.ContainsKey(type))
            {
                if (dicEventType.TryGetValue(type, out var actionList))
                {
                    if (actionList != null && actionList.Any())
                    {
                        foreach (var item in actionList)
                        {
                            if (item is EventHander<T>)
                            {
                                EventHander<T> eventHander = item as EventHander<T>;
                                if (eventHander != null && eventHander.func != null && (string.IsNullOrEmpty(eventData.MethodName) || eventHander.func.Method.Name == eventData.MethodName))
                                {
                                    object obj = eventHander.HandleEventFunc(eventData);
                                    list.Add(obj);
                                }
                            }
                        }
                    }
                }
            }
            return list;
        }


        /// <summary>
        /// 异步执行不带返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="eventData"></param>
        /// <returns></returns>
        public static Task PublishAsync<T>()
        {
            EventData<T> eventData = new EventData<T>();
            return PublishAsync(eventData);
        }
        public static Task PublishAsync<T>(string eventName)
        {
            EventData<T> eventData = new EventData<T>() { EventName = eventName };
            return PublishAsync(eventData);
        }
        public static Task PublishAsync<T>(T t)
        {
            EventData<T> eventData = new EventData<T>() { Data = t };
            return PublishAsync(eventData);
        }
        public static Task PublishAsync<T>(string eventName, T t)
        {
            EventData<T> eventData = new EventData<T>() { EventName = eventName, Data = t };
            return PublishAsync(eventData);
        }
        public static Task PublishAsync<T>(string methodName, string eventName)
        {
            EventData<T> eventData = new EventData<T>() { MethodName = methodName, EventName = eventName};
            return PublishAsync(eventData);
        }
        public static Task PublishAsync<T>(string methodName, string eventName, T t)
        {
            EventData<T> eventData = new EventData<T>() { MethodName = methodName, EventName = eventName, Data = t };
            return PublishAsync(eventData);
        }
        public static Task PublishAsync<T>(EventData<T> eventData)
        {
            return Instance.PrivatePublishAsync(eventData);
        }
        private Task PrivatePublishAsync<T>(EventData<T> eventData)
        {
            Task task = Task.Run(()=> true);
            Type type = typeof(T);
            if (dicEventType.ContainsKey(type))
            {
                if (dicEventType.TryGetValue(type, out var actionList))
                {
                    if (actionList != null && actionList.Any())
                    {
                        foreach (var item in actionList)
                        {
                            if (item is EventHanderAsync<T>)
                            {
                                EventHanderAsync<T> eventHander = item as EventHanderAsync<T>;

                                if (eventHander != null && eventHander.funcVoid != null && (string.IsNullOrEmpty(eventData.MethodName) || eventHander.funcVoid.Method.Name == eventData.MethodName))
                                {
                                    task = eventHander.HandleEventVoid(eventData);
                                }
                            }
                        }
                    }
                }
            }
            return task;
        }


        /// <summary>
        /// 异步执行带返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="eventData"></param>
        /// <returns></returns>
        public static Task PublishResultAsync<T>()
        {
            EventData<T> eventData = new EventData<T>();
            return PublishResultAsync(eventData);
        }
        public static Task PublishResultAsync<T>(string eventName)
        {
            EventData<T> eventData = new EventData<T>() { EventName = eventName };
            return PublishResultAsync(eventData);
        }
        public static Task PublishResultAsync<T>(T t)
        {
            EventData<T> eventData = new EventData<T>() { Data = t };
            return PublishResultAsync(eventData);
        }
        public static Task PublishResultAsync<T>(string methodName, T t)
        {
            EventData<T> eventData = new EventData<T>() { MethodName = methodName, Data = t };
            return PublishResultAsync(eventData);
        }
        public static Task PublishResultAsync<T>(string methodName, string eventName)
        {
            EventData<T> eventData = new EventData<T>() { MethodName = methodName, EventName = eventName };
            return PublishResultAsync(eventData);
        }
        public static Task PublishResultAsync<T>(string methodName, string eventName, T t)
        {
            EventData<T> eventData = new EventData<T>() { MethodName = methodName, EventName = eventName, Data = t };
            return PublishResultAsync(eventData);
        }
        public static Task<List<object>> PublishResultAsync<T>(EventData<T> eventData)
        {
            return Instance.PrivatePublishResultAsync(eventData);
        }
        private async Task<List<object>> PrivatePublishResultAsync<T>(EventData<T> eventData)
        {
            List<object> list = new List<object>();
            Type type = typeof(T);
            if (dicEventType.ContainsKey(type))
            {
                if (dicEventType.TryGetValue(type, out var actionList))
                {
                    if (actionList != null && actionList.Any())
                    {
                        foreach (var item in actionList)
                        {
                            if (item is EventHanderAsync<T>)
                            {
                                EventHanderAsync<T> eventHander = item as EventHanderAsync<T>;
                                if (eventHander != null && eventHander.func != null && (string.IsNullOrEmpty(eventData.MethodName) || eventHander.func.Method.Name == eventData.MethodName))
                                {
                                    object obj = await eventHander.HandleEventObj(eventData);
                                    list.Add(obj);
                                }
                            }
                        }
                    }
                }
            }
            return list;
        }
        #endregion

        #endregion

        #region 函数名称订阅执行集合

        private ConcurrentDictionary<string, List<IEventData>> dicEventMethod = new ConcurrentDictionary<string, List<IEventData>>();

        #region 订阅

        /// <summary>
        /// 同步订阅无返回值
        /// </summary>
        /// <param name="action"></param>
        public static void Subscribe(Action<EventData> action)
        {
            if (action != null && action.Method != null && !string.IsNullOrEmpty(action.Method.Name))
            {
                IEventData eventHander = new EventHander(action, null);
                Instance.PrivateSubscribe(action.Method.Name, eventHander);
            }
        }

        /// <summary>
        /// 同步订阅带返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="func"></param>
        public static void SubscribeResult(Func<EventData, object> func)
        {
            if (func != null && func.Method != null && !string.IsNullOrEmpty(func.Method.Name))
            {
                IEventData eventHander = new EventHander(null, func);
                Instance.PrivateSubscribe(func.Method.Name, eventHander);
            }
        }

        /// <summary>
        /// 异步订阅不返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="func"></param>
        public static void SubscribeAsync(Func<EventData, Task> func)
        {
            if (func != null && func.Method != null && !string.IsNullOrEmpty(func.Method.Name))
            {
                IEventData eventHander = new EventHanderAsync(func, null);
                Instance.PrivateSubscribe(func.Method.Name, eventHander);
            }
        }

        /// <summary>
        /// 异步订阅带返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="func"></param>
        public static void SubscribeResultAsync(Func<EventData, Task<object>> func)
        {
            if (func != null && func.Method != null && !string.IsNullOrEmpty(func.Method.Name))
            {
                IEventData eventHander = new EventHanderAsync(null, func);
                Instance.PrivateSubscribe(func.Method.Name, eventHander);
            }
        }

        private void PrivateSubscribe(string methodName, IEventData eventHander)
        {
            if (!dicEventMethod.ContainsKey(methodName))
            {
                dicEventMethod[methodName] = new List<IEventData>();
            }
            if (dicEventMethod.TryGetValue(methodName, out var eventDatas))
            {
                if (eventDatas != null)
                {
                    eventDatas.Add(eventHander);
                }
            }
        }

        #endregion

        #region 执行

        /// <summary>
        /// 同步执行不带返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="eventData"></param>
        public static void Publish(string methodName)
        {
            EventData eventData = new EventData() { MethodName = methodName };
            Publish(eventData);
        }
        public static void Publish(string methodName, string eventName)
        {
            EventData eventData = new EventData() { EventName = eventName, MethodName = methodName };
            Publish(eventData);
        }
        public static void Publish(string methodName, object data)
        {
            EventData eventData = new EventData() { MethodName = methodName, Data = data };
            Publish(eventData);
        }
        public static void Publish(string methodName, string eventName,  object data)
        {
            EventData eventData = new EventData() { EventName = eventName, MethodName = methodName, Data = data };
            Publish(eventData);
        }
        public static void Publish(EventData eventData)
        {
            Instance.PrivatePublish(eventData);
        }
        private void PrivatePublish(EventData eventData)
        {
            if (eventData != null && !string.IsNullOrEmpty(eventData.MethodName) && dicEventMethod.ContainsKey(eventData.MethodName))
            {
                if (dicEventMethod.TryGetValue(eventData.MethodName, out var eventDatas))
                {
                    if (eventDatas != null && eventDatas.Any())
                    {
                        foreach (var item in eventDatas)
                        {
                            if (item is EventHander)
                            {
                                EventHander eventHander = item as EventHander;

                                if (eventHander != null && eventHander.action != null && (string.IsNullOrEmpty(eventData.MethodName) || eventHander.action.Method.Name == eventData.MethodName))
                                {
                                    eventHander.HandleEventViod(eventData);
                                }
                            }
                        }
                    }
                }
            }
        }


        /// <summary>
        /// 同步执行带返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="eventData"></param>
        /// <returns></returns>
        public static void PublishResult(string methodName)
        {
            EventData eventData = new EventData() { MethodName = methodName };
            PublishResult(eventData);
        }
        public static void PublishResult(string methodName, object data)
        {
            EventData eventData = new EventData() { MethodName = methodName, Data = data };
            PublishResult(eventData);
        }
        public static void PublishResult(string methodName, string eventName)
        {
            EventData eventData = new EventData() { MethodName = methodName, EventName = eventName };
            PublishResult(eventData);
        }
        public static void PublishResult(string methodName, string eventName, object data)
        {
            EventData eventData = new EventData() { MethodName = methodName, EventName = eventName, Data = data };
            PublishResult(eventData);
        }
        public static List<object> PublishResult(EventData eventData)
        {
            return Instance.PrivatePublishResult(eventData);
        }
        private List<object> PrivatePublishResult(EventData eventData)
        {
            List<object> list = new List<object>();
            if (eventData != null && !string.IsNullOrEmpty(eventData.MethodName) && dicEventMethod.ContainsKey(eventData.MethodName))
            {
                if (dicEventMethod.TryGetValue(eventData.MethodName, out var eventDatas))
                {
                    if (eventDatas != null && eventDatas.Any())
                    {
                        foreach (var item in eventDatas)
                        {
                            if (item is EventHander)
                            {
                                EventHander eventHander = item as EventHander;
                                if (eventHander != null && eventHander.func != null && (string.IsNullOrEmpty(eventData.MethodName) || eventHander.func.Method.Name == eventData.MethodName))
                                {
                                    object obj = eventHander.HandleEventObj(eventData);
                                    list.Add(obj);
                                }
                            }
                        }
                    }
                }
            }
            return list;
        }


        /// <summary>
        /// 异步执行不带返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="eventData"></param>
        /// <returns></returns>
        public static Task PublishAsync(string methodName)
        {
            EventData eventData = new EventData() { MethodName = methodName };
            return PublishAsync(eventData);
        }
        public static Task PublishAsync(string methodName, object data)
        {
            EventData eventData = new EventData() { MethodName = methodName, Data = data };
            return PublishAsync(eventData);
        }
        public static Task PublishAsync(string methodName, string eventName)
        {
            EventData eventData = new EventData() { MethodName = methodName, EventName = eventName };
            return PublishAsync(eventData);
        }
        public static Task PublishAsync(string methodName, string eventName, object data)
        {
            EventData eventData = new EventData() { MethodName = methodName, EventName = eventName, Data = data };
            return PublishAsync(eventData);
        }
        public static Task PublishAsync(EventData eventData)
        {
            return Instance.PrivatePublishAsync(eventData);
        }
        private async Task PrivatePublishAsync(EventData eventData)
        {
            if (eventData != null && !string.IsNullOrEmpty(eventData.MethodName) && dicEventMethod.ContainsKey(eventData.MethodName))
            {
                if (dicEventMethod.TryGetValue(eventData.MethodName, out var eventDatas))
                {
                    if (eventDatas != null && eventDatas.Any())
                    {
                        foreach (var item in eventDatas)
                        {
                            if (item is EventHanderAsync)
                            {
                                EventHanderAsync eventHander = item as EventHanderAsync;

                                if (eventHander != null && eventHander.funcVoid != null && (string.IsNullOrEmpty(eventData.MethodName) || eventHander.funcVoid.Method.Name == eventData.MethodName))
                                {
                                    await eventHander.HandleEventVoid(eventData);
                                }
                            }
                        }
                    }
                }
            }
        }


        /// <summary>
        /// 异步执行带返回值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="eventData"></param>
        /// <returns></returns>
        public static Task<List<object>> PublishResultAsync(string methodName)
        {
            EventData eventData = new EventData() { MethodName = methodName };
            return PublishResultAsync(eventData);
        }
        public static Task<List<object>> PublishResultAsync(string methodName, object data)
        {
            EventData eventData = new EventData() { MethodName = methodName, Data = data };
            return PublishResultAsync(eventData);
        }
        public static Task<List<object>> PublishResultAsync(string methodName, string eventName)
        {
            EventData eventData = new EventData() { MethodName = methodName, EventName = eventName };
            return PublishResultAsync(eventData);
        }
        public static Task<List<object>> PublishResultAsync(string methodName, string eventName, object data)
        {
            EventData eventData = new EventData() { MethodName = methodName, EventName = eventName, Data = data };
            return PublishResultAsync(eventData);
        }
        public static Task<List<object>> PublishResultAsync(EventData eventData)
        {
            return Instance.PrivatePublishResultAsync(eventData);
        }
        private async Task<List<object>> PrivatePublishResultAsync(EventData eventData)
        {
            List<object> list = new List<object>();
            if (eventData != null && !string.IsNullOrEmpty(eventData.MethodName) && dicEventMethod.ContainsKey(eventData.MethodName))
            {
                if (dicEventMethod.TryGetValue(eventData.MethodName, out var eventDatas))
                {
                    if (eventDatas != null && eventDatas.Any())
                    {
                        foreach (var item in eventDatas)
                        {
                            if (item is EventHanderAsync)
                            {
                                EventHanderAsync eventHander = item as EventHanderAsync;
                                if (eventHander != null && eventHander.func != null && (string.IsNullOrEmpty(eventData.MethodName) || eventHander.func.Method.Name == eventData.MethodName))
                                {
                                    object obj = await eventHander.HandleEventObj(eventData);
                                    list.Add(obj);
                                }
                            }
                        }
                    }
                }
            }
            return list;
        }

        #endregion

        #endregion

        #region 移除订阅
        public static void RemoveAll()
        {
            Instance.dicEventType.Clear();
            Instance.dicEventMethod.Clear();
        }

        public static void Remove<T>()
        {
            Type type = typeof(T);
            if (Instance.dicEventType.ContainsKey(type))
            {
                Instance.dicEventType.TryRemove(type, out _);
            }
        }

        public static void Remove<T>(string methodName)
        {
            Type type = typeof(T);
            if (Instance.dicEventType.ContainsKey(type))
            {
                if (Instance.dicEventType.TryGetValue(type, out var eventDatas))
                {
                    List<EventHander<T>> eventHanders = new List<EventHander<T>>();
                    List<EventHanderAsync<T>> eventHanderAsyncs = new List<EventHanderAsync<T>>();
                    foreach (var item in eventDatas)
                    {
                        if (item is EventHander<T>)
                        {
                            EventHander<T> eventHander = item as EventHander<T>;
                            if (eventHander != null)
                            {
                                if (eventHander.action != null && eventHander.action.Method.Name != methodName)
                                {
                                    eventHanders.Add(eventHander);
                                }
                                if (eventHander.func != null && eventHander.func.Method.Name != methodName)
                                {
                                    eventHanders.Add(eventHander);
                                }
                            }
                        }
                        else if (item is EventHanderAsync<T>)
                        {
                            EventHanderAsync<T> eventHander = item as EventHanderAsync<T>;
                            if (eventHander != null)
                            {
                                if (eventHander.funcVoid != null && eventHander.funcVoid.Method.Name != methodName)
                                {
                                    eventHanderAsyncs.Add(eventHander);
                                }
                                if (eventHander.func != null && eventHander.func.Method.Name != methodName)
                                {
                                    eventHanderAsyncs.Add(eventHander);
                                }
                            }
                        }
                    }
                    eventDatas.Clear();
                    if (eventHanders.Any())
                    {
                        foreach (var item in eventHanders)
                        {
                            eventDatas.Add(item);
                        }
                    }
                    if (eventHanderAsyncs.Any())
                    {
                        foreach (var item in eventHanderAsyncs)
                        {
                            eventDatas.Add(item);
                        }
                    }
                }
            }
        }

        public static void Remove(string methodName)
        {
            if (Instance.dicEventMethod.ContainsKey(methodName))
            {
                Instance.dicEventMethod.TryRemove(methodName, out _);
            }
        }
        #endregion
    }
}

六. 非常推荐大家下载使用

slimewang

关注

11
点赞
踩
9

收藏

觉得还不错? 一键收藏
1
评论
C#实现一个自己的事件总线EventBus框架

事件总线（EventBus）用于在软件组件之间实现松耦合通信。它提供了一种分发、订阅的方式在应用程序内各个组件之间传递消息。而这些组件可以是对象、模块、模型、控制器等等。事件总线的核心思想是发布者/订阅者模型。事件总线提供了一个中介的角色，使得发布者和订阅者不需要直接互相联系，而是将消息发布到事件总线，事件总线再将消息转发给所有订阅者。事件总线可以用于实现解耦合的组件之间的通信，也可以用于实现模块化的设计，减少应用程序的复杂度，并提高代码的可维护性和可重用性。
复制链接

扫一扫