事件总线（在有些框架中也称时间聚合器，如Prism的EventAggregater）是订阅-发布模式的一种实现，类似观察者模式，相对于观察者模式，事件总线更灵活，它是一种集中处理事件的模式，允许不同组件之间通信，降低耦合度。
事件总线的三要素：事件源（事件的定义）、发布事件（触发事件）、订阅事件（事件的应答实现）。
实现事件总线，主要工作是事件基类、参数基类、事件自动注册的定义，基于需求场景的业务型事件，只需要按照预定义的规则增加上述三要素即可，大大降低业务复杂度，且可实现一对一、一对多，多对一，同步应答、异步应答等方式。
1、定义事件基类（抽象类）
public abstract class MyEventBase
{
public string EventName { get; set; }
}
2、事件参数的基类（抽象类）
public abstract class MyEventArgs<T>:EventArgs
{
public T Argument { get; set; }
}
3、事件的基类（无返回值的事件基类，因无返回值，可异步调用，也可同步调用，建议异步调用）
public class MyEvent<T>: MyEventBase where T : EventArgs
{
protected static readonly object lockObject = new object();
protected readonly List<Action<object, T>> subscribers = new List<Action<object, T>>();
public void Subscribe(Action<object, T> eventHandler)
{
lock (lockObject)
{
if (!subscribers.Contains(eventHandler))
{
subscribers.Add(eventHandler);
}
}
}
public void Unsubscribe(Action<object, T> eventHandler)
{
lock (lockObject)
{
if (subscribers.Contains(eventHandler))
{
subscribers.Remove(eventHandler);
}
}
}
public virtual void Publish(object sender, T eventArgs)
{
lock (lockObject)
{
for (int i = 0; i < subscribers.Count; i++)
{
subscribers[i](sender, eventArgs);
}
}
}
}
4、事件的基类（有返回值事件的基类，因需要获取返回值，一般采用同步方式调用）
public class MyEventWithResult<T1, T2> : MyEventBase where T1 : EventArgs
{
protected static readonly object lockObject = new object();
protected readonly List<Func<object, T1, T2>> subscribers = new List<Func<object, T1, T2>>();
public void Subscribe(Func<object, T1, T2> eventHandler)
{
lock (lockObject)
{
if (!subscribers.Contains(eventHandler))
{
subscribers.Add(eventHandler);
}
}
}
public void Unsubscribe(Func<object, T1, T2> eventHandler)
{
lock (lockObject)
{
if (subscribers.Contains(eventHandler))
{
subscribers.Remove(eventHandler);
}
}
}
public virtual T2 Publish(object sender, T1 eventArgs)
{
T2 result = default;
lock (lockObject)
{
for (int i = 0; i < subscribers.Count; i++)
{
result = subscribers[i](sender, eventArgs);
}
}
return result;
}
}
5、事件中心，负责自动装载事件
public class MyEventAggregator
{
private static MyEventAggregator _default;
private static readonly object _locker = new object();
private readonly Dictionary<Type, MyEventBase> _eventAggregator = new Dictionary<Type, MyEventBase>();
/// <summary>
/// 默认事件总线实例，建议只使用此实例
/// </summary>
public static MyEventAggregator Default
{
get
{
if (_default == null)
{
lock (_locker)
{
// 如果类的实例不存在则创建，否则直接返回
if (_default == null)
{
_default = new MyEventAggregator();
}
}
}
return _default;
}
}
/// <summary>
/// 构造函数，自动加载EventBase的派生类实现
/// </summary>
public MyEventAggregator()
{
Type type = typeof(MyEventBase);
Assembly assembly = Assembly.GetAssembly(type);
//注册时需排除的基类
Type typeMyEvent = typeof(MyEvent<>);
Type typeMyEventWithResult = typeof(MyEventWithResult<,>);
List<Type> typeList2 = assembly.GetTypes()
.Where(t => t != type && t!=typeAnalysisEvent && t != typeMyEventWithResult && type.IsAssignableFrom(t))
.ToList();
foreach (var item in typeList2)
{
MyEventBase eventBase = (MyEventBase)assembly.CreateInstance(item.FullName);
_eventAggregator.Add(item, eventBase);
}
}
/// <summary>
/// 获取事件实例
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
/// <returns></returns>
public TEvent GetEvent<TEvent>() where TEvent : MyEventBase
{
return (TEvent)_eventAggregator[typeof(TEvent)];
}
/// <summary>
/// 添加事件类型
/// </summary>
/// <typeparam name="TEvent"></typeparam>
public void AddEvent<TEvent>() where TEvent : MyEventBase, new()
{
lock (_locker)
{
Type type = typeof(TEvent);
if (!_eventAggregator.ContainsKey(type))
{
_eventAggregator.Add(type, new TEvent());
}
}
}
/// <summary>
/// 移除事件类型
/// </summary>
/// <typeparam name="TEvent"></typeparam>
public void RemoveEvent<TEvent>() where TEvent : MyEventBase, new()
{
lock (_locker)
{
Type type = typeof(TEvent);
if (_eventAggregator.ContainsKey(type))
{
_eventAggregator.Remove(type);
}
}
}
}
}
6、具体事件的定义和调用示例
定义
/// <summary>
/// 添加日志 事件
/// </summary>
public class WriteLogEvent : MyEvent<WriteLogEventArgs>
{
public override void Publish(object sender, WriteLogEventArgs eventArgs)
{
for (int i = 0; i < subscribers.Count; i++)
{
var action = subscribers[i];
Task.Run(() => action(sender, eventArgs));
}
}
}
public class WriteLogEventArgs : MyEventArgs<WriteLogEventArgs2> { };
public class WriteLogEventArgs2
{
/// <summary>
/// 日志内容
/// </summary>
public string Msg { get; set; }
/// <summary>
/// 操作类型
/// </summary>
public OperationType OperationType { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Remark { get; set; }
/// <summary>
/// 目标类型
/// </summary>
public LogTargetType LogTargetType { get; set; }
/// <summary>
/// 目标值
/// </summary>
public string TargetValue { get; set; }
}
发布事件
MyEventAggregator.Default.GetEvent<WriteLogEvent>().Publish(this, new WriteLogEventArgs
{
Argument = new WriteLogEventArgs2
{
Msg = logMsg,
OperationType = OperationType.Save,
LogTargetType = LogTargetType.OriginalData,
TargetValue = targetValue,
Remark = _MPIComment
}
});
订阅事件
MyEventAggregator.Default.GetEvent<WriteLogEvent>().Subscribe(WriteLogEventHandler);
private void WriteLogEventHandler(object sender, WriteLogEventArgs e)
{
-----business logic
-----
}