事件总线知多少(2)

源码路径:Github-EventBus 事件总线知多少(1) 事件总线知多少(2)

1.引言

之前的一篇文章事件总线知多少(1),介绍了什么是事件总线,并通过发布订阅模式一步一步的分析重构,形成了事件总线的Alpha版本,这篇文章也得到了大家的肯定和积极的反馈和建议,在此谢谢大家。本着继续学习和回馈大家的思想,我决定继续完善。本文将继续延续上一篇循序渐进的写作风格,来完成对事件总线的分析和优化。

2.回顾事件总线

在进行具体分析之前,我们还是先对我们实现的事件总线进行一个简单的回顾:

  1. 针对事件源,抽象IEventData接口;
  2. 针对事件处理,抽象IEventHandler<TEventData>接口,定义唯一事件处理方法void HandleEvent(IEventData eventData)
  3. 事件总线维护一个事件源和事件处理的类型映射字典ConcurrentDictionary<Type, List<Type>> _eventAndHandlerMapping
  4. 通过单例模式,确保事件总线的唯一入口;
  5. 利用反射完成事件源与事件处理的动态初始化绑定;
  6. 提供入口支持事件的手动注册/取消注册;
  7. 提供统一的事件触发接口,通过反射动态创建IEventHandler实例完成具体事件处理逻辑的调用。

3.发现反射问题

基于以上的简单回顾,我们可以发现Alpha版本事件总线的成功离不开反射的支持。从动态绑定到动态触发,都是反射在默默的处理着业务逻辑。如果我们只是简单学习了解事件总线,使用反射无可厚非。但如果在实际的项目中,使用反射却不是一个很明智的行为,因为其性能问题。尤其是事件总线要集中处理整个应用程序的所有事件,更易导致程序性能瓶颈。 既然说到了反射性能,那就顺便解释下为什么反射性能差?

  1. 类型绑定(元数据字符串匹配)
  2. 参数校验
  3. 安全校验
  4. 基于运行时
  5. 反射产生大量临时对象,增加GC负担

那既然反射有性能瓶颈,我们该如何是好呢? 你可能会说,既然反射有问题,那就对反射进行性能优化,比如增加缓存机制。出发点是好的,但最终还是在反射问题的阴影之下。对于反射我们应该持以这样一种态度:能不用反射,则不用反射。

那既然要推翻反射这条路,那如何解决动态绑定和动态触发的问题呢? 办法总比问题多。额,啊,嗯。就不饶圈子了,咱们上IOC。

4.使用IOC解除依赖

先看下面一张图,来了解下DIP、IOC、DI与SL之间的关系,详细可参考Asp.net mvc 知多少(十)

下面我们就以Castle Windsor作为我们的IOC容器为例,来讲解下如何解除依赖。

4.1. 了解Castle Windsor

使用Castle Windsor主要包含以下几步:

  1. 初始化容器:var container = new WindsorContainer();
  2. 使用WindsorInstallers从执行程序集添加和配置所有组件:container.Install(FromAssembly.This());
  3. 实现IWindsorInstaller自定义安装器:
public class RepositoriesInstaller : IWindsorInstaller
{
public void Install(IWindsorContainer container, IConfigurationStore store)
{
    container.Register(Classes.FromThisAssembly()
                        .Where(Component.IsInSameNamespaceAs<King>())
                        .WithService.DefaultInterfaces()
                        .LifestyleTransient());
}
}

4.注册和解析依赖

5.程序退出时,释放容器

4.2. 使用Castle Windsor

使用IOC容器的目的很明确,一个是在注册事件时完成依赖的注入,一个是在触发事件时完成依赖的解析。从而完成事件的动态绑定和触发。

4.2.1. 初始化容器

要在EventBus这个类中完成事件依赖的注入和解析,就需要在本类中持有一个对IWindsorContainer的引用。 可以直接定义一个只读属性,并在构造函数中进行初始化即可。

public IWindsorContainer IocContainer { get; private set; }//定义IOC容器
private readonly ConcurrentDictionary<Type, List<Type>> _eventAndHandlerMapping;
public EventBus()
{
      IocContainer = new WindsorContainer();
      _eventAndHandlerMapping = new ConcurrentDictionary<Type, List<Type>>();
}

4.2.2.注册和取消注册依赖

初始化完容器,我们需要在手动注册和取消注册事件API上分别完成依赖的注册和取消注册。因为Castle Windsor在3.0版本取消了UnRegister方法,所以在进行事件注册时,就不再手动卸载IOC容器中已注册的依赖。

/// <summary>
/// 手动绑定事件源与事件处理
/// </summary>
/// <param name="eventType"></param>
/// <param name="handlerType"></param>
 public void Register(Type eventType, Type handlerType)
 {
     //注册IEventHandler<T>到IOC容器
     var handlerInterface = handlerType.GetInterface("IEventHandler`1");
     if (!IocContainer.Kernel.HasComponent(handlerInterface))
     {
         IocContainer.Register(Component.For(handlerInterface, handlerType));
     }

     //注册到事件总线
     //省略其他代码
}

/// <summary>
/// 手动解除事件源与事件处理的绑定
/// </summary>
/// <typeparam name="TEventData"></typeparam>
/// <param name="handlerType"></param>
public void UnRegister<TEventData>(Type handlerType)
{
    _eventAndHandlerMapping.GetOrAdd(typeof(TEventData), (type) => new List<Type>())
        .RemoveAll(t => t == handlerType);
}

4.2.3. 动态事件绑定

要实现事件的动态绑定,我们要拿到所有IEventHandler<T>的实现。而遍历所有类型最好的办法就是拿到程序集(Assembly)。拿到程序集后就可以将所有IEventHandler<T>的实现注册到IOC容器,然后再基于IOC容器注册的IEventHandler<T>动态映射事件源和事件处理。

/// <summary>
/// 提供入口支持注册其它程序集中实现的IEventHandler
/// </summary>
/// <param name="assembly"></param>
public void RegisterAllEventHandlerFromAssembly(Assembly assembly)
{
    //1.将IEventHandler注册到Ioc容器
    IocContainer.Register(Classes.FromAssembly(assembly)
        .BasedOn(typeof(IEventHandler<>))
        .WithService.AllInterfaces()
        .LifestyleSingleton());

    //2.从IOC容器中获取注册的所有IEventHandler
    var handlers = IocContainer.Kernel.GetHandlers(typeof(IEventHandler));
    foreach (var handler in handlers)
    {
        //循环遍历所有的IEventHandler<T>
        var interfaces = handler.ComponentModel.Implementation.GetInterfaces();
        foreach (var @interface in interfaces)
        {
            if (!typeof(IEventHandler).IsAssignableFrom(@interface))
            {
                continue;
            }

            //获取泛型参数类型
            var genericArgs = @interface.GetGenericArguments();
            if (genericArgs.Length == 1)
            {
                //注册到事件源与事件处理的映射字典中
                Register(genericArgs[0], handler.ComponentModel.Implementation);
            }
        }
    }
}

通过这种方式,我们就可以再其他需要使用事件总线的项目中,添加引用后,通过调用以下代码,来完成程序集中IEventHandler<T>的动态绑定。

//注册当前程序集中实现的所有IEventHandler<T>
EventBus.Default.RegisterAllEventHandlerFromAssembly(Assembly.GetExecutingAssembly());

4.2.4. 动态事件触发

触发事件时主要分三步,第一步从事件源与事件处理的字典中取出映射的IEventHandler集合,第二步使用IOC容器解析依赖,第三步调用HandleEvent方法。代码如下:

/// <summary>
/// 根据事件源触发绑定的事件处理
/// </summary>
/// <typeparam name="TEventData"></typeparam>
/// <param name="eventData"></param>
public void Trigger<TEventData>(TEventData eventData) where TEventData : IEventData
{
    //获取所有映射的EventHandler
    List<Type> handlerTypes = _eventAndHandlerMapping[typeof(TEventData)];

    if (handlerTypes != null && handlerTypes.Count > 0)
    {
        foreach (var handlerType in handlerTypes)
        {
            //从Ioc容器中获取所有的实例
            var handlerInterface = handlerType.GetInterface("IEventHandler`1");
            var eventHandlers = IocContainer.ResolveAll(handlerInterface);

            //循环遍历,仅当解析的实例类型与映射字典中事件处理类型一致时,才触发事件
            foreach (var eventHandler in eventHandlers)
            {
                if (eventHandler.GetType() == handlerType)
                {
                    var handler = eventHandler as IEventHandler<TEventData>;
                    handler.HandleEvent(eventData);
                }
            }
        }
    }
}

5.用例完善

我们上面使用IOC容器替换了反射,在程序的易用性和性能上都有所提升。但很显然,用例不够完善且存在一些潜在问题,比如:

  1. 支持Action EventHandler的绑定和触发
  2. 异步触发
  3. 触发指定的EventHandler
  4. 线程安全
  5. 等等等

下面我们就来先一一完善以上几个问题。

5.1.支持Action事件处理器

如果每一个事件处理都要定义一个类去实现IEventHandler<T>接口,很显然会造成类急剧膨胀。且在一些简单场景,定义一个类又大才小用。这时我们应该立刻想到Action。 使用Action,第一步我们要对其进行封装,提供一个公共的ActionEventHandler来统一处理所有的Action事件处理器。代码如下:

/// <summary>
/// 支持Action的事件处理器
/// </summary>
/// <typeparam name="TEventData"></typeparam>
internal class ActionEventHandler<TEventData> : IEventHandler<TEventData> where TEventData : IEventData
{
    /// <summary>
    /// 定义Action的引用,并通过构造函数传参初始化
    /// </summary>
    public Action<TEventData> Action { get; private set; }

    public ActionEventHandler(Action<TEventData> handler)
    {
        Action = handler;
    }

    /// <summary>
    /// 调用具体的Action来处理事件逻辑
    /// </summary>
    /// <param name="eventData"></param>
    public void HandleEvent(TEventData eventData)
    {
        Action(eventData);
    }
}

有了ActionEventHandler做封装,下一步就是注入IOC容器并注册到事件总线了。

 /// <summary>
 /// 注册Action事件处理器
 /// </summary>
 /// <typeparam name="TEventData"></typeparam>
 /// <param name="action"></param>
 public void Register<TEventData>(Action<TEventData> action) where TEventData : IEventData
 {
     //1.构造ActionEventHandler
     var actionHandler = new ActionEventHandler<TEventData>(action);

     //2.将ActionEventHandler的实例注入到Ioc容器
     IocContainer.Register(
         Component.For<IEventHandler<TEventData>>()
         .UsingFactoryMethod(() => actionHandler)
         .LifestyleSingleton());

     //3.注册到事件总线
     Register<TEventData>(actionHandler);
 }

使用起来就很简单:

//注册Action事件处理器
EventBus.Default.Register<EventData>(
    actionEventData =>
    {
        Trace.TraceInformation(actionEventData.EventTime.ToLongDateString());
    });
//触发
EventBus.Default.Trigger(new EventData());

5.2. 支持异步触发

异步触发很简单直接使用Task.Run包装一下就ok了。

/// <summary>
/// 异步触发
/// </summary>
/// <typeparam name="TEventData"></typeparam>
/// <param name="eventData"></param>
/// <returns></returns>
public Task TriggerAsync<TEventData>(TEventData eventData) where TEventData : IEventData
{
    return Task.Run(() => Trigger<TEventData>(eventData));
}

5.3.触发指定EventHandler

在我们的Trigger方法中我们会将某一个事件源绑定的事件处理全部触发。但在某些场景下,我们可能并不需要全部触发,仅需要触发指定的EventHandler。这个需求很实际,我们来实现一下。

/// <summary>
/// 触发指定EventHandler
/// </summary>
/// <param name="eventHandlerType"></param>
/// <param name="eventData"></param>

public void Trigger<TEventData>(Type eventHandlerType, TEventData eventData) 
    where TEventData : IEventData
{
    //获取类型实现的泛型接口
    var handlerInterface = eventHandlerType.GetInterface("IEventHandler`1");

    var eventHandlers = IocContainer.ResolveAll(handlerInterface);

    //循环遍历,仅当解析的实例类型与映射字典中事件处理类型一致时,才触发事件
    foreach (var eventHandler in eventHandlers)
    {
        if (eventHandler.GetType() == eventHandlerType)
        {
            var handler = eventHandler as IEventHandler<TEventData>;
            handler?.HandleEvent(eventData);
        }
    }
}
/// <summary>
/// 异步触发指定EventHandler
/// </summary>
/// <param name="eventHandlerType"></param>
/// <param name="eventData"></param>
/// <returns></returns>
public Task TriggerAsycn<TEventData>(Type eventHandlerType, TEventData eventData)
    where TEventData : IEventData
{
    return Task.Run(() => Trigger(eventHandlerType, eventData));
}

上个测试用例:

 [Fact]
public async void Should_Call_Specified_Handler_Async()
{
    TestEventBus.Register<TestEventData>(new TestEventHandler());

    var count = 0;
    TestEventBus.Register<TestEventData>(
        actionEventData => { count++; }
    );
    await TestEventBus.TriggerAsycn<TestEventData>
        (typeof(TestEventHandler), new TestEventData(999));

    TestEventHandler.TestValue.ShouldBe(999);
    count.ShouldBe(0);
}

5.4.线程安全问题

在事件总线中,维护的事件源和事件处理的映射字典是整个程序中的重中之重。我们选择了使用ConcurrentDictionary线程安全字典来规避线程安全问题。但实际我们真正做到线程安全了吗?我们看下映射字典申明:

        /// <summary>
        /// 定义线程安全集合
        /// </summary>
        private readonly ConcurrentDictionary<Type, List<Type>> _eventAndHandlerMapping;

聪慧如你,我们的事件源支持绑定多个事件处理,ConcurrentDictionary确保了对key值(事件源)修改的线程安全,但无法确保事件处理的列表List<Type>的线程安全。那我们就来动手改造吧。同样代码很简单:

/// <summary>
/// 定义锁对象
/// </summary>
private static object lockObj= new object();

/// <summary>
/// 获取事件总线映射字典中指定事件源的事件列表
/// 若有,返回列表
/// 若无,构造空列表返回
/// </summary>
/// <param name="eventType"></param>
/// <returns></returns>
private List<Type> GetOrCreateHandlers(Type eventType)
{
    return _eventAndHandlerMapping.GetOrAdd(eventType, (type) => new List<Type>());
}

public void Register(Type eventType, Type handlerType)
{
    //省略其他代码
    //注册到事件总线
    lock (lockObj)
    {
        GetOrCreateHandlers(eventType).Add(handlerType);
    }
}
public void UnRegister<TEventData>(Type handlerType)
{
    lock (lockObj)
    {
        GetOrCreateHandlers(typeof(TEventData)).RemoveAll(t => t == handlerType);
    }
}

6.单元测试

为了确保重构的正确性和业务的完整性,以上的改进都是基于单元测试进行改进的,使用的是Xunit+Shouldly。虽然不能保证单元测试的覆盖度,但至少确保了正常业务的流转。

7.总结

这一次,通过单元测试,一步一步的推进事件总线的重构和完善。主要完成了使用IOC替换反射来解耦和一些用例的完善。源码已上传至Github(源码路径:Github-EventBus)。

至此,事件总线进入Beta版本。但很显然还有许多细节有待完善,比如异常处理等,后续就不再继续这个系列,我会直接维护Github的源码,感兴趣的可自行参阅。

参考资料: ABP EventBus [c#] 反射真的很可怕吗?

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Greenplum

Linux 常用命令(三)

curl 命令支持在线下载功能,使用方便,它支持,S,等协议,还支持PUT,POST,COOKIES,认证授权等操作。

2490
来自专栏前端知识分享

第109天:Ajax请求GET和POST的区别

  用get方式可传送简单数据,但大小一般限制在1KB下,数据追加到url中发送(http的header传送),也就是说,浏览器将各个表单字段元素及其数据按照U...

1792
来自专栏娱乐心理测试

一个 JS 库就能解决小程序跨页传递事件消息和数据

由于微信小程序 wx.navigateBack 方法并不支持返回传值,导致页面在返回后,不能方便地即时更新数据。

2204
来自专栏c#开发者

Asp.net Webform 使用Repository模式实现CRUD操作代码生成工具

Asp.net Webform 使用Repository模式实现CRUD操作代码生成工具 介绍 该工具是通过一个github上的开源项目修改的原始作者https...

4458
来自专栏大内老A

[WCF REST] 通过ASP.NET Output Caching实现声明式缓存

ASP.NET的输出缓存(Output Caching)机制允许我们针对整个Web页面或者页面的某个部分(主要针对用户控件)最终呈现的HTML进行缓存。对于后续...

1916
来自专栏博客园

深入浅出话资源

我们把有用的东西称为资源。“兵马未动,粮草先行”-----程序中的各种数据就是算法的原料和粮草。程序中可以存放数据的地方有很多,可以放在数据库里、可以存储在变量...

1052
来自专栏FreeBuf

AutoIt木马又一发:暗藏神秘照片

AutoIt是一个自动化的Windows界面交互的脚本语言,具有很高的灵活性和较低的学习曲线。由于AutoIt解释器本身属于合法程序,黑客可以把恶意代码藏在脚本...

3289
来自专栏沃趣科技

看各路神仙如何大战MySQL insecure warning报警有感

一、问题由来 mysql在5.6.5上开始在命令行中直接填入用户密码会提示错误,例如: $./mysql -h10.10.30.18 -uwoqutech -p...

4628
来自专栏菩提树下的杨过

ASP.Net MVC框架配置与分析

前几年的时候ASP.Net就有MVC的概念,实际上就是我们熟悉的WebForm开发模型。 1、Model层与视图无关,并且只与数据库相关: 伪代码: puli...

20610
来自专栏Golang语言社区

package http

要管理代理、TLS配置、keep-alive、压缩和其他设置,创建一个Transport:

2294

扫码关注云+社区

领取腾讯云代金券