学习自事件总线知多少（1）
事件总线是对发布-订阅模式的一种实现。它是一种集中式事件处理机制，允许不同的组件之间进行彼此通信而又不需要相互依赖，达到一种解耦的目的。

处理流程

事件之事件总线 - 图2
事件是由事件源触发并由事件处理消费（An event is raised by an event source and consumed by an event handler）。

发布订阅模式

:::warning 定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。 ——发布订阅模式 ::: 发布订阅模式主要有两个角色：

  • 发布方（Publisher）：也称为被观察者，当状态改变时负责通知所有订阅者。
  • 订阅方（Subscriber）：也称为观察者，订阅事件并对接收到的事件进行处理。

发布订阅模式有两种实现方式：

  • 简单的实现方式：由Publisher维护一个订阅者列表，当状态改变时循环遍历列表通知订阅者。
  • 委托的实现方式：由Publisher定义事件委托，Subscriber实现委托。

    发布订阅模式流程
    事件之事件总线 - 图3

    钓鱼示例

    事件是由事件源和事件处理组成。
    钓鱼:鱼儿咬钩，鱼竿通过铃铛通知垂钓者收钩。 ```csharp

namespace EventBus.Demo;

///

/// 鱼的品类枚举 /// public enum FishType { 鲫鱼, 鲤鱼, 黑鱼, 青鱼, 草鱼, 鲈鱼 }

  1. <a name="dXwgY"></a>
  2. ### 提取事件源
  3. 事件源应该至少包含事件发生的时间和触发事件的对象。<br />我们提取IEventData接口来封装事件源：
  4. ```csharp
  6. namespace EventBus.Demo;
  8. /// <summary>
  9. /// 定义事件源接口，所有的事件源都要实现该接口
  10. /// </summary>
  11. public interface IEventData
  12. {
  13.     /// <summary>
  14.     /// 事件发生的时间
  15.     /// </summary>
  16.     DateTime EventTime { get; set; }
  18.     /// <summary>
  19.     /// 触发事件的对象
  20.     /// </summary>
  21.     object EventSource { get; set; }
  22. }

自然我们应该给一个默认的事件源实现EventData：

  2. namespace EventBus.Demo;
  4. /// <summary>
  5. /// 默认的事件源实现
  6. /// 事件源：描述事件信息，用于参数传递
  7. /// </summary>
  8. public class EventData : IEventData
  9. {
  10.     /// <summary>
  11.     /// 事件发生的时间
  12.     /// </summary>
  13.     public DateTime EventTime { get; set; }
  15.     /// <summary>
  16.     /// 触发事件的对象
  17.     /// </summary>
  18.     public Object EventSource { get; set; }
  20.     public EventData()
  21.     {
  22.         EventTime = DateTime.Now;
  23.     }
  24. }

针对钓鱼Demo，扩展事件源如下：

  2. namespace EventBus.Demo;
  4. /// <summary>
  5. /// 扩展事件源-钓鱼
  6. /// </summary>
  7. public class FishingEventData : EventData
  8. {
  9.     public FishType FishType { get; set; }
  10.     public FishingMan FishingMan { get; set; }
  11. }

鱼竿的实现，这里用随机数模拟鱼儿咬钩

  2. namespace EventBus.Demo;
  4. /// <summary>
  5. ///     鱼竿（被观察者）
  6. /// </summary>
  7. public class FishingRod
  8. {
  9.     public delegate void FishingHandler(FishingEventData type); //声明委托
  10.     public event FishingHandler FishingEvent; //声明事件
  12.     public void ThrowHook(FishingMan man)
  13.     {
  14.         Console.WriteLine("开始下钩！");
  16.         //用随机数模拟鱼咬钩，若随机数为偶数，则为鱼咬钩
  17.         if (new Random().Next() % 2 == 0)
  18.         {
  19.             var type = (FishType)new Random().Next(0, 5);
  20.             //鱼儿咬钩，鱼竿通过铃铛通知垂钓者收钩
  21.             Console.WriteLine("铃铛：叮叮叮，鱼儿咬钩了");
  23.             var eventData = new FishingEventData() { FishType = type, FishingMan = man };
  25.             FishingEvent?.Invoke(eventData);
  26.         }
  27.     }
  28. }

垂钓者实现观察者接口

  2. namespace EventBus.Demo;
  4. /// <summary>
  5. /// 垂钓者（观察者）
  6. /// </summary>
  7. public class FishingMan
  8. {
  9.     public FishingMan(string name)
  10.     {
  11.         Name = name;
  12.     }
  14.     public string Name { get; set; }
  15.     public int FishCount { get; set; }
  17.     /// <summary>
  18.     /// 垂钓者自然要有鱼竿啊
  19.     /// </summary>
  20.     public FishingRod FishingRod { get; set; }
  22.     public void Fishing()
  23.     {
  24.         this.FishingRod.ThrowHook(this);
  25.     }
  26.     /// <summary>
  27.     /// 鱼儿咬钩，鱼竿通过铃铛通知垂钓者收钩
  28.     /// </summary>
  29.     /// <param name="type"></param>
  30.     public void Update(FishingEventData type)
  31.     {
  32.         FishCount++;
  33.         Console.WriteLine("{0}：钓到一条[{2}]，已经钓到{1}条鱼了！", Name, FishCount, type);
  34.     }
  35. }

到这一步我们就统一了事件源的定义方式。

提取事件处理器

事件源统一了，那事件处理也得加以限制。比如如果随意命名事件处理方法名，那在进行事件注册的时候还要去按照委托定义的参数类型去匹配，岂不麻烦。
我们提取一个IEventHandler接口：

  2. namespace EventBus.Demo;
  4. /// <summary>
  5. /// 定义事件处理器公共接口，所有的事件处理都要实现该接口
  6. /// </summary>
  7. public interface IEventHandler
  8. {
  9. }

事件处理要与事件源进行绑定，所以我们再来定义一个泛型接口：

  2. namespace EventBus.Demo;
  4. /// <summary>
  5. /// 定义事件处理器公共接口，所有的事件处理都要实现该接口
  6. /// </summary>
  7. public interface IEventHandler
  8. {
  9. }
  10. /// <summary>
  11. /// 泛型事件处理器接口
  12. /// </summary>
  13. /// <typeparam name="TEventData"></typeparam>
  14. public interface IEventHandler<TEventData> : IEventHandler where TEventData : IEventData
  15. {
  16.     /// <summary>
  17.     /// 事件处理器实现该方法来处理事件
  18.     /// </summary>
  19.     /// <param name="eventData"></param>
  20.     void HandleEvent(TEventData eventData);
  21. }

至此我们就完成了事件处理的抽象。我们再继续去改造我们的Demo。FishingMan实现IEventHandler接口，

  2. namespace EventBus.Demo;
  4. /// <summary>
  5. /// 定义事件处理器公共接口，所有的事件处理都要实现该接口
  6. /// </summary>
  7. public interface IEventHandler
  8. {
  9. }
  10. /// <summary>
  11. /// 泛型事件处理器接口
  12. /// </summary>
  13. /// <typeparam name="TEventData"></typeparam>
  14. public interface IEventHandler<TEventData> : IEventHandler where TEventData : IEventData
  15. {
  16.     /// <summary>
  17.     /// 事件处理器实现该方法来处理事件
  18.     /// </summary>
  19.     /// <param name="eventData"></param>
  20.     void HandleEvent(TEventData eventData);
  21. }

然后修改场景类中将fishingRod.FishingEvent += jeff.Update;改为fishingRod.FishingEvent += jeff.HandleEvent;即可。

  1. //观察者模式(事件总线实现方式)--钓鱼:鱼儿咬钩，鱼竿通过铃铛通知垂钓者收钩。
  2. using EventBus.Demo;
  4. //1、初始化鱼竿
  5. var fishingRod = new FishingRod();
  7. //2、声明垂钓者
  8. var jeff = new FishingMan("圣杰");
  10. //3.分配鱼竿
  11. jeff.FishingRod = fishingRod;
  13. //4、注册观察者
  14. //fishingRod.FishingEvent += jeff.Update;
  15. fishingRod.FishingEvent += jeff.HandleEvent;
  17. //5、循环钓鱼
  18. while (jeff.FishCount < 5)
  19. {
  20.     jeff.Fishing();
  21.     Console.WriteLine("-------------------");
  22.     //睡眠5s
  23.     Thread.Sleep(5000);
  24. }

至此，这个模式实现到这个地步基本已经可以通用了。

实现IEventHandler

针对不同的事件源IEventData实现不同的IEventHandler。

  2. namespace EventBus.Demo;
  4. /// <summary>
  5. /// 钓鱼事件处理
  6. /// 针对不同的事件源IEventData实现不同的IEventHandler
  7. /// </summary>
  8. public class FishingEventHandler : IEventHandler<FishingEventData>
  9. {
  10.     public void HandleEvent(FishingEventData eventData)
  11.     {
  12.         eventData.FishingMan.FishCount++;
  14.         Console.WriteLine("{0}：钓到一条[{2}]，已经钓到{1}条鱼了！",
  15.             eventData.FishingMan.Name, eventData.FishingMan.FishCount, eventData.FishType);
  17.     }
  18. }

这时我们就可以移除在FishingMan中实现的IEventHandler接口了。
然后将事件注册改为fishingRod.FishingEvent += new FishingEventHandler().HandleEvent;即可。

  1. //观察者模式(事件总线实现方式)--钓鱼:鱼儿咬钩，鱼竿通过铃铛通知垂钓者收钩。
  2. using EventBus.Demo;
  4. //1、初始化鱼竿
  5. var fishingRod = new FishingRod();
  7. //2、声明垂钓者
  8. var jeff = new FishingMan("圣杰");
  10. //3.分配鱼竿
  11. jeff.FishingRod = fishingRod;
  13. //4、注册观察者
  14. //fishingRod.FishingEvent += jeff.Update;
  15. //fishingRod.FishingEvent += jeff.HandleEvent;
  16. fishingRod.FishingEvent += new FishingEventHandler().HandleEvent;
  18. //5、循环钓鱼
  19. while (jeff.FishCount < 5)
  20. {
  21.     jeff.Fishing();
  22.     Console.WriteLine("-------------------");
  23.     //睡眠5s
  24.     Thread.Sleep(5000);
  25. }

统一注册事件

我们可以通过反射来进行事件的统一注册。
在FishingRod的构造函数中使用反射，统一注册实现了IEventHandler类型的实例方法HandleEvent：

  2. using System.Reflection;
  4. namespace EventBus.Demo;
  6. /// <summary>
  7. /// 鱼竿（被观察者）
  8. /// </summary>
  9. public class FishingRod
  10. {
  11.     public delegate void FishingHandler(FishingEventData type); //声明委托
  12.     public event FishingHandler FishingEvent; //声明事件
  14.     /// <summary>
  15.     /// 统一注册事件
  16.     /// 在FishingRod的构造函数中使用反射，统一注册实现了IEventHandler<FishingEventData>类型的实例方法HandleEvent
  17.     /// </summary>
  18.     public FishingRod()
  19.     {
  20.         Assembly assembly = Assembly.GetExecutingAssembly();
  22.         foreach (var type in assembly.GetTypes())
  23.         {
  24.             if (typeof(IEventHandler).IsAssignableFrom(type))//判断当前类型是否实现了IEventHandler接口
  25.             {
  26.                 Type handlerInterface = type.GetInterface("IEventHandler`1");//获取该类实现的泛型接口
  27.                 Type eventDataType = handlerInterface?.GetGenericArguments()[0]; // 获取泛型接口指定的参数类型
  29.                 //如果参数类型是FishingEventData，则说明事件源匹配
  30.                 if (eventDataType!=null&&eventDataType.Equals(typeof(FishingEventData)))
  31.                 {
  32.                     //创建实例
  33.                     var handler = Activator.CreateInstance(type) as IEventHandler<FishingEventData>;
  34.                     //注册事件
  35.                     FishingEvent += handler.HandleEvent;
  36.                 }
  37.             }
  38.         }
  39.     }
  41.     public void ThrowHook(FishingMan man)
  42.     {
  43.         Console.WriteLine("开始下钩！");
  45.         //用随机数模拟鱼咬钩，若随机数为偶数，则为鱼咬钩
  46.         if (new Random().Next() % 2 == 0)
  47.         {
  48.             var type = (FishType)new Random().Next(0, 5);
  49.             //鱼儿咬钩，鱼竿通过铃铛通知垂钓者收钩
  50.             Console.WriteLine("铃铛：叮叮叮，鱼儿咬钩了");
  52.             var eventData = new FishingEventData() { FishType = type, FishingMan = man };
  54.             FishingEvent?.Invoke(eventData);
  55.         }
  56.     }
  57. }

这样，我们就可以移出场景类中的显示注册代码fishingRod.FishingEvent += new FishingEventHandler().HandleEvent;。

解除依赖

如何解除依赖呢？其实答案就在本文的两张图上，仔细对比我们可以很直观的看到，Event Bus就相当于一个介于Publisher和Subscriber中间的桥梁。它隔离了Publlisher和Subscriber之间的直接依赖，接管了所有事件的发布和订阅逻辑，并负责事件的中转。
Event Bus终于要粉墨登场了！！！
分析一下，如果EventBus要接管所有事件的发布和订阅，那它则需要有一个容器来记录事件源和事件处理。那又如何触发呢？有了事件源，我们就自然能找到绑定的事件处理逻辑，通过反射触发。代码如下：

  1. using System;
  2. using System.Collections.Concurrent;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Reflection;
  6. using System.Text;
  7. using System.Threading.Tasks;
  9. namespace EventBus.Demo;
  11. /// <summary>
  12. /// 事件总线
  13. /// </summary>
  14. public class EventBus
  15. {
  16.     public static EventBus Default => new EventBus();
  18.     /// <summary>
  19.     /// 定义线程安全集合
  20.     /// </summary>
  21.     private readonly ConcurrentDictionary<Type, List<Type>> _eventAndHandlerMapping;
  23.     public EventBus()
  24.     {
  25.         _eventAndHandlerMapping = new ConcurrentDictionary<Type, List<Type>>();
  26.         MapEventToHandler();
  27.     }
  29.     /// <summary>
  30.     ///通过反射，将事件源与事件处理绑定
  31.     /// </summary>
  32.     private void MapEventToHandler()
  33.     {
  34.         Assembly assembly = Assembly.GetEntryAssembly();
  35.         foreach (var type in assembly.GetTypes())
  36.         {
  37.             if (typeof(IEventHandler).IsAssignableFrom(type))//判断当前类型是否实现了IEventHandler接口
  38.             {
  39.                 Type handlerInterface = type.GetInterface("IEventHandler`1");//获取该类实现的泛型接口
  40.                 if (handlerInterface != null)
  41.                 {
  42.                     Type eventDataType = handlerInterface.GetGenericArguments()[0]; // 获取泛型接口指定的参数类型
  44.                     if (_eventAndHandlerMapping.ContainsKey(eventDataType))
  45.                     {
  46.                         List<Type> handlerTypes = _eventAndHandlerMapping[eventDataType];
  47.                         handlerTypes.Add(type);
  48.                         _eventAndHandlerMapping[eventDataType] = handlerTypes;
  49.                     }
  50.                     else
  51.                     {
  52.                         var handlerTypes = new List<Type> { type };
  53.                         _eventAndHandlerMapping[eventDataType] = handlerTypes;
  54.                     }
  55.                 }
  56.             }
  57.         }
  58.     }
  60.     /// <summary>
  61.     /// 手动绑定事件源与事件处理
  62.     /// </summary>
  63.     /// <typeparam name="TEventData"></typeparam>
  64.     /// <param name="eventHandler"></param>
  65.     public void Register<TEventData>(Type eventHandler)
  66.     {
  67.         List<Type> handlerTypes = _eventAndHandlerMapping[typeof(TEventData)];
  68.         if (!handlerTypes.Contains(eventHandler))
  69.         {
  70.             handlerTypes.Add(eventHandler);
  71.             _eventAndHandlerMapping[typeof(TEventData)] = handlerTypes;
  72.         }
  73.     }
  75.     /// <summary>
  76.     /// 手动解除事件源与事件处理的绑定
  77.     /// </summary>
  78.     /// <typeparam name="TEventData"></typeparam>
  79.     /// <param name="eventHandler"></param>
  80.     public void UnRegister<TEventData>(Type eventHandler)
  81.     {
  82.         List<Type> handlerTypes = _eventAndHandlerMapping[typeof(TEventData)];
  83.         if (handlerTypes.Contains(eventHandler))
  84.         {
  85.             handlerTypes.Remove(eventHandler);
  86.             _eventAndHandlerMapping[typeof(TEventData)] = handlerTypes;
  87.         }
  88.     }
  90.     /// <summary>
  91.     /// 根据事件源触发绑定的事件处理
  92.     /// </summary>
  93.     /// <typeparam name="TEventData"></typeparam>
  94.     /// <param name="eventData"></param>
  95.     public void Trigger<TEventData>(TEventData eventData) where TEventData : IEventData
  96.     {
  97.         List<Type> handlers = _eventAndHandlerMapping[eventData.GetType()];
  99.         if (handlers != null && handlers.Count > 0)
  100.         {
  101.             foreach (var handler in handlers)
  102.             {
  103.                 MethodInfo methodInfo = handler.GetMethod("HandleEvent");
  104.                 if (methodInfo != null)
  105.                 {
  106.                     object obj = Activator.CreateInstance(handler);
  107.                     methodInfo.Invoke(obj, new object[] { eventData });
  108.                 }
  109.             }
  110.         }
  111.     }
  112. }

事件总线主要定义三个方法，注册、取消注册、事件触发。还有一点就是我们在构造函数中通过反射去进行事件源和事件处理的绑定。
代码注释已经很清楚了，这里就不过多解释了。
下面我们就来修改Demo，修改FishingRod的事件触发：

  1.     public void ThrowHook(FishingMan man)
  2.     {
  3.         Console.WriteLine("开始下钩！");
  5.         //用随机数模拟鱼咬钩，若随机数为偶数，则为鱼咬钩
  6.         if (new Random().Next() % 2 == 0)
  7.         {
  8.             var type = (FishType)new Random().Next(0, 5);
  9.             //鱼儿咬钩，鱼竿通过铃铛通知垂钓者收钩
  10.             Console.WriteLine("铃铛：叮叮叮，鱼儿咬钩了");
  12.             var eventData = new FishingEventData() { FishType = type, FishingMan = man };
  14.             //FishingEvent(eventData);//不再需要通过事件委托触发
  15.             EventBus.Default.Trigger<FishingEventData>(eventData);//直接通过事件总线触发即可
  16.         }
  17.     }

事件总线的总结

通过上面一步一步的分析和实践，发现事件总线也不是什么高深的概念，只要我们自己善于思考，勤于动手，也能实现自己的事件总线。
根据我们的实现，大概总结出以下几条：

  1. 事件总线维护一个事件源与事件处理的映射字典；
  2. 通过单例模式，确保事件总线的唯一入口；
  3. 利用反射完成事件源与事件处理的初始化绑定；
  4. 提供统一的事件注册、取消注册和触发接口。

    继续完善

    请参考事件总线知多少（2）