什么是事件总线呢？官方的文档说，它是一个单例对象，由其他的类共同拥有，可以用来触发和处理事件。这个东西确实比较陌生，为什么要使用事件总线，或者说事件总线的优势是什么？？？首先我们可以明确的是，事件总线的出现是用来代替我们传统的事件的，那么我们传统的事件到底有什么不好呢？？我们由浅入深，慢慢研究。
事件我们都比较熟悉，我们用两个例子回顾一下。
1.第一个例子，以前我们在winform的开发程序中到处都是事件，比如
sender:触发事件的对象
e:事件的数据，传递参数
方法中的内容：事件的处理逻辑。
2.第二个例子，发布-订阅模式
发布者：创建委托事件，然后调用委托事件（触发事件）
订阅者：编写事件的触发逻辑
以猫捉老鼠的故事为例子
猫
public class Cat
{
/// <summary>
/// 事件的处理逻辑
/// </summary>
/// <param name="mouseName"></param>
public void CatchMouse(string mouseName)
{
Console.WriteLine("小猫说：\n");
Console.WriteLine("我抓住了{0}",mouseName);
}
}
老鼠
public class Mouse
{
//定义委托
public delegate void CommingHandler(string name);
//声明事件委托
public event CommingHandler CommingEventHandler;
public Mouse(string name)
{
this.Name = name;
}
public void Comming(string name)
{
Console.WriteLine("老鼠说：\n"); Console.WriteLine("我的名字是{0},I am Comming!", name);
//发布事件
CommingEventHandler(name);
}
public string Name { get; set; } }
猫捉老鼠
class Program
{
static void Main(string[] args)
{ Cat c1 = new Cat();
Mouse m1 = new Mouse("1号老鼠");
//订阅事件
m1.CommingEventHandler += c1.CatchMouse;
//触发事件
m1.Comming(m1.Name);
Console.ReadLine();
} }
从上面的两个例子中，我们可以总结一点东西，如何组成一个事件？？
第一个例子：sender+e+事件的处理逻辑=事件
第二个例子：老鼠+老鼠的名字+CatchMouse的处理逻辑=事件
触发事件的对象+描述事件的参数+事件触发的处理逻辑=事件
前两个参数都是老鼠的参量统称为事件源，后一个参数是猫的动作统称为事件的处理，所以事件的本质就是事件源和事件的处理逻辑。
现在又有一个问题来了，如果出现一个需求，我们的猫要订阅一个猫吃一只多少斤鱼的事件FishCommingEventHandler，怎么做呢？此时事件源变成了鱼，事件的逻辑变成了”猫吃鱼“，这个动作，我们通常的做法一般都是重新定义一个委托事件，然后完成相应的处理逻辑。由此可以看出，我们的事件通用性很差劲，每次出现新的需求都需要重新写处理逻辑。变化的点：事件源和事件的处理。
二. 通用的发布-订阅模式
（1）抽象事件源
为了统一事件源的变化，我们定义一个抽象的父类
/// <summary>
/// 抽象事件源接口
/// </summary>
public interface IEventData
{
/// <summary>
/// 触发事件的对象
/// </summary>
object EventSource { get; set; }
/// <summary>
/// 触发事件的时间
/// </summary>
DateTime EventTime { get; set; }
}
/// <summary>
/// 所有的事件源都必须继承的父类，事件源就是参数，传递参数的作用，相当于老鼠的名字，鱼的名字
/// </summary>
public class EventData : IEventData
{
public object EventSource { get ; set ; }
public DateTime EventTime { get; set; }
public EventData()
{
EventTime = DateTime.Now;
}
}
/// <summary>
/// 自定义参数，封装变化
/// </summary>
public class SelfDefineEventData:EventData
{
public string MouseName { get; set; }
public float FishWeight{ get; set; }
}
(2)接下来就是对事件逻辑进行处理，统一事件触发的方法，如果事件的方法不同一，将会造成通用性变差，同时需要手动匹配事件源，所以需要注意的是事件源和事件的处理是绑定在一起的。
/// <summary>
/// 标志接口，mark
/// </summary>
public interface IEventHandler
{ }
/// <summary>
/// 泛型接口，事件源和事件的处理是一起的
/// </summary>
/// <typeparam name="TEventData"></typeparam>
public interface IEventHandler<TEventData> : IEventHandler where TEventData : IEventData
{
/// <summary>
/// 根据事件源，做出相应的处理
/// </summary>
/// <param name="eventData"></param>
void Handle(TEventData eventData);
}
我们为事件1 （猫捉老鼠）和事件2 （猫吃了一只XX的鱼）定义一个统一的委托类
public delegate void SelfDefineEventHandler(SelfDefineEventData eventData);
修改我们老鼠的类和鱼类
public class Mouse
{ //声明事件委托
public event SelfDefineEventHandler selfEventHandler;
public Mouse(string name)
{
this.Name = name;
}
public void Comming(string name )
{
Console.WriteLine("老鼠说：\n"); Console.WriteLine("我的名字是{0},I am Comming!", name);
//触发事件
selfEventHandler(new SelfDefineEventData() { MouseName=name});
}
public string Name { get; set; } }
public class Fish
{
//声明事件委托
public event SelfDefineEventHandler selfEventHandler;
public Fish(int weight)
{
this.Weight = weight;
}
public void Comming(int weight)
{
Console.WriteLine("小鱼说：\n"); Console.WriteLine("我的重量是{0},I am Comming!", weight);
//触发事件
selfEventHandler(new SelfDefineEventData() { FishWeight = weight }); public int Weight { get; set; }
}
从上面的代码中，由于我们统一了事件源EventData,委托参数保证了一致性，所以实现了委托的共用。
修改我们的猫类
public class Cat:IEventHandler<SelfDefineEventData>
{
/// <summary>
/// 事件的处理逻辑
/// </summary>
/// <param name="mouseName"></param>
public void CatchMouse(string mouseName)
{
Console.WriteLine("小猫说：\n");
Console.WriteLine("我抓住了{0}",mouseName);
} public void Handle(SelfDefineEventData eventData)
{
//处理猫捉老鼠
if(!string.IsNullOrEmpty(eventData.MouseName))
{
Console.WriteLine("小猫说：\n");
Console.WriteLine("我抓住了{0}", eventData.MouseName); }
//处理猫吃鱼
if (eventData.FishWeight != )
{
Console.WriteLine("小猫说：\n");
Console.WriteLine("我吃了{0}斤鱼", eventData.FishWeight);
}
}
}
猫捉老鼠和猫吃鱼
static void Main(string[] args)
{ Cat c1 = new Cat();
Mouse m1 = new Mouse("1号老鼠");
Fish f1 = new Fish();
//订阅事件
m1.selfEventHandler += c1.Handle;
//这边的事件变量定义的名字一样了，可以用不同的名字区分，这是事件不是委托
f1.selfEventHandler += c1.Handle;
//触发事件
m1.Comming(m1.Name);
f1.Comming(f1.Weight);
Console.ReadLine();
}
从上面的代码可以看出我们统一了事件处理逻辑为Handle
上面的代码从逻辑上来看，每次都是同时触发执行了所有的注册事件，那么如果我需要只触发一个事件？？？？那么我们只需要对传入参数EventData进行判断即可，方案有两个：
1.直接在SelfDefineEventData中将EventSource赋值为Mouse和Fish，然后在Handle方法中判断EventSource的类型
这种方式是承接上面的实现代码的，突然发现一个问题，上面的代码虽然可以跑的通，但是有一种过度封装的感觉，本来每一个XXEventData都是继承自EventData,都是一个独立的模块，所以我们上面的代码违背了单一性原则
2.分别定义两个EventData:FishEventData和MouseEventData,然后在Handle中判断eventData的类型，所以我们采用这种方法，并将前面的代码重新修改
定义事件源
public class MouseEventData : EventData
{
public string MouseName { get; set; }
}
public class FishEventData : EventData
{
public float FishWeight { get; set; }
}
修改鱼和老鼠类
public class Mouse
{ //声明事件委托
public event MouserEventHandler selfEventHandler;
public Mouse(string name)
{
this.Name = name;
}
public void Comming(string name )
{
Console.WriteLine("老鼠说：\n"); Console.WriteLine("我的名字是{0},I am Comming!", name);
//触发事件
selfEventHandler(new MouseEventData() { MouseName = name});
}
public string Name { get; set; } }
public class Fish
{
//声明事件委托
public event FishEventHandler selfEventHandler;
public Fish(float weight)
{
this.Weight = weight;
}
public void Comming(float weight)
{
Console.WriteLine("小鱼说：\n"); Console.WriteLine("我的重量是{0},I am Comming!", weight);
//触发事件
selfEventHandler(new FishEventData() { FishWeight = weight });
}
public float Weight { get; set; }
}
定义不同的事件委托
public delegate void MouserEventHandler(MouseEventData eventData );
public delegate void FishEventHandler(FishEventData eventData);
修改猫类
public class Cat:IEventHandler<IEventData>
{ public void Handle(IEventData eventData)
{
if (eventData is MouseEventData)
{
var mouseData = (MouseEventData)eventData;
//处理猫捉老鼠
if (!string.IsNullOrEmpty(mouseData.MouseName))
{
Console.WriteLine("小猫说：\n");
Console.WriteLine("我抓住了{0}", mouseData.MouseName); }
}
if (eventData is FishEventData)
{
var fishData = (FishEventData)eventData;
//处理猫吃鱼
if (fishData.FishWeight != )
{
Console.WriteLine("小猫说：\n");
Console.WriteLine("我吃了{0}斤鱼", fishData.FishWeight);
}
}
}
}
重新实现猫捉老鼠
class Program
{
static void Main(string[] args)
{ Cat c1 = new Cat();
Mouse m1 = new Mouse("1号老鼠"); //订阅事件
m1.selfEventHandler += c1.Handle;
//触发事件
m1.Comming(m1.Name); Console.ReadLine();
} }
发现一个问题
原来父类参数事件可以赋值给子类参数事件上，哈哈
到此为止，我们的发布订阅模式已经完成，所以每次有新的需求，只需要分别定制XXEventData,体现了一种模块化，单一性的思想，同时将事件处理进行统一，体现了封装统一的思想，两者结合恰到好处。
参考文章：事件知多少https://www.jianshu.com/p/22fbe7a7c120