当前位置: 首页>编程语言>正文

mediationr语言 mediatorr

源码相关

MediaR是一个中介者库,里面实现了请求响应/发布订阅两种模式。

内部相当于一个容器,由源码可知,内部创建时注入了一个容器委托(从容器中获得对应的实现接口的实例)。

// 这里注入了一个委托,用于是从服务容器中获取对应项实例。
        public Mediator(ServiceFactory serviceFactory)
        {
            _serviceFactory = serviceFactory;
        }
// 这一段有两个方法,一个是获得一个实例,一个是获得所有实现了这个接口的实例,这个是给发布订阅用的。    

public delegate object ServiceFactory(Type serviceType);

    public static class ServiceFactoryExtensions
    {
        public static T GetInstance<T>(this ServiceFactory factory)
            => (T) factory(typeof(T));

        public static IEnumerable<T> GetInstances<T>(this ServiceFactory factory)
            => (IEnumerable<T>) factory(typeof(IEnumerable<T>));
    }

获得所有的订阅者后,将在Mediator的方法Publish依次调用,如果途中取消,可以使用CancellationToken进行标记。

protected virtual async Task PublishCore(IEnumerable<Func<INotification, CancellationToken, Task>> allHandlers, INotification notification, CancellationToken cancellationToken)
        {
            foreach (var handler in allHandlers)
            {
                await handler(notification, cancellationToken).ConfigureAwait(false);
            }
        }

发布订阅排序问题

问题:NOP中可以有顺序,那么问题来了,从上面看来,MediatR并没有给我们对订阅者排序的选择。那么我们如何才能对事件处理者排序呢?

目前有两种方式,第一种是修改MediatR的 源码,添加特性

namespace MediatR.Attributes
{
    [AttributeUsage(AttributeTargets.Class)]
    public sealed class EventOrderAttribute : Attribute
    {
        /// <summary>
        /// 排序值。
        /// </summary>
        public int Order { get; set; }
    }
}

总所周知,依赖注入一个接口多个实现的时候,可以通过IEnumerable获得所有的实现。

因此,我们可以在获取势力的时候,即上面的方法ServiceFactoryExtensions.IEnumerable<T> GetInstances<T>(this ServiceFactory factory)中处理

如下:

public static class ServiceFactoryExtensions
    {
        public static T GetInstance<T>(this ServiceFactory factory)
            => (T)factory(typeof(T));

        public static IEnumerable<T> GetInstances<T>(this ServiceFactory factory)
        {
            var instanceList = (IEnumerable<T>)factory(typeof(IEnumerable<T>));

       // 反射进行排序。
            if (instanceList.Any(o => o.GetType().GetCustomAttributes().Any(o => o.GetType().Equals(typeof(EventOrderAttribute)))))
                instanceList = instanceList
                    .OrderBy(o => o.GetType().GetCustomAttribute<EventOrderAttribute>() == null ? 0 : o.GetType().GetCustomAttribute<EventOrderAttribute>().Order).ToList();
            return instanceList;
        }

当然,以上方案是不推荐的,毕竟修改了核心源码,但我们依然可以利用容器的特性,安装一定顺序进行排序,然后依次注入,即可实现上面一样的效果。

首先依然保留原来的特性,这次我们把魔手伸向

MediatR.Extensions.Microsoft.DependencyInjection 这个项目中,一下只是为了快速参考,所以直接改这个,你也可以自己实现一个。

在这个项目中,主要的是ServiceRegistrar这个类,进行注册,里面是以此注入不同的接口。

关注:ServiceRegistrar.ConnectImplementationsToTypesClosing方法

private static void ConnectImplementationsToTypesClosing(Type openRequestInterface,
            IServiceCollection services,
            IEnumerable<Assembly> assembliesToScan,
            bool addIfAlreadyExists)
        {
            // 这个集合收集中保存的是处理者。
            var concretions = new List<Type>();

            // 这个集合保存的是处理者的接口。
            var interfaces = new List<Type>();
            foreach (var type in assembliesToScan.SelectMany(a => a.DefinedTypes).Where(t => !t.IsOpenGeneric()))
            {
                var interfaceTypes = type.FindInterfacesThatClose(openRequestInterface).ToArray();
                if (!interfaceTypes.Any()) continue;

                if (type.IsConcrete())
                {
                    concretions.Add(type);
                }

                foreach (var interfaceType in interfaceTypes)
                {
                    interfaces.Fill(interfaceType);
                }
            }

            // 这一部分是将接口与相应的实例者相匹配,然后注册到容器中。
            foreach (var @interface in interfaces)
            {
                var exactMatches = concretions.Where(x => x.CanBeCastTo(@interface)).ToList();
                if (addIfAlreadyExists)
                {
                    foreach (var type in exactMatches)
                    {
                        services.AddTransient(@interface, type);
                    }
                }
                else
                {
                    if (exactMatches.Count > 1)
                    {
                        exactMatches.RemoveAll(m => !IsMatchingWithInterface(m, @interface));
                    }

                    // 针对一个接口的注册,注入多个矗立着。
                    foreach (var type in exactMatches)
                    {
                        services.TryAddTransient(@interface, type);
                    }
                }

                if (!@interface.IsOpenGeneric())
                {
                    AddConcretionsThatCouldBeClosed(@interface, concretions, services);
                }
            }
        }

那么我们也只需要按照这种形式,先排序在一次注入到容器中。

如下:

private static void ConnectImplementationsToTypesClosing(Type openRequestInterface,
            IServiceCollection services,
            IEnumerable<Assembly> assembliesToScan,
            bool addIfAlreadyExists)
        {
            // 这个集合收集中保存的是处理者。
            var concretions = new List<Type>();

            // 新增一个用于收集排序的集合。
            var concretionsOrder = new List<Type>();

            // 这个集合保存的是处理者的接口。
            var interfaces = new List<Type>();
            foreach (var type in assembliesToScan.SelectMany(a => a.DefinedTypes).Where(t => !t.IsOpenGeneric()))
            {
                var interfaceTypes = type.FindInterfacesThatClose(openRequestInterface).ToArray();
                if (!interfaceTypes.Any()) continue;

                if (type.IsConcrete())
                {
                    if (type.GetCustomAttributes().Any(o => o.GetType().Equals(typeof(EventOrderAttribute))))
                        concretionsOrder.Add(type);
                    else
                        concretions.Add(type);
                }

                foreach (var interfaceType in interfaceTypes)
                {
                    interfaces.Fill(interfaceType);
                }
            }

            // 排序后加入到服务中。
            concretionsOrder = OrderService(concretionsOrder);
            AddService(concretions);
            AddService(concretionsOrder);

            // 排序服务。
            List<Type> OrderService(List<Type> typeList)
            {
                if (typeList.Any())
                    return typeList.OrderBy(o => o.GetCustomAttribute<EventOrderAttribute>().Order).ToList();
                else
                    return typeList;
            }

            // 添加服务。
            void AddService(List<Type> typeList)
            {
                // 这一部分是将接口与相应的实例者相匹配,然后注册到容器中。
                foreach (var @interface in interfaces)
                {
                    var exactMatches = typeList.Where(x => x.CanBeCastTo(@interface)).ToList();
                    if (addIfAlreadyExists)
                    {
                        foreach (var type in exactMatches)
                        {
                            services.AddTransient(@interface, type);
                        }
                    }
                    else
                    {
                        if (exactMatches.Count > 1)
                        {
                            exactMatches.RemoveAll(m => !IsMatchingWithInterface(m, @interface));
                        }

                        // 针对一个接口的注册,注入多个矗立着。
                        foreach (var type in exactMatches)
                        {
                            services.TryAddTransient(@interface, type);
                        }
                    }

                    if (!@interface.IsOpenGeneric())
                    {
                        AddConcretionsThatCouldBeClosed(@interface, typeList, services);
                    }
                }
            }
        }

下面是ABC对应321.

[EventOrder(Order = 3)]
    public class AClHandler : INotificationHandler<EventData>
    {
        public Task Handle(EventData notification, CancellationToken cancellationToken)
        {
            Console.WriteLine(nameof(AClHandler));
            return Task.CompletedTask;
        }
    }

    [EventOrder(Order = 2)]
    public class BClHandler : INotificationHandler<EventData>
    {
        public Task Handle(EventData notification, CancellationToken cancellationToken)
        {
            Console.WriteLine(nameof(BClHandler));
            return Task.CompletedTask;
        }
    }

    [EventOrder(Order = 1)]
    public class CClHandler : INotificationHandler<EventData>
    {
        public Task Handle(EventData notification, CancellationToken cancellationToken)
        {
            Console.WriteLine(nameof(CClHandler));
            return Task.CompletedTask;
        }
    }

看看结果:

mediationr语言 mediatorr,mediationr语言 mediatorr_List,第1张

 

 

  如果去掉排序

mediationr语言 mediatorr,mediationr语言 mediatorr_mediationr语言_02,第2张

 第二种先排序再插入容器的方法,或许不适用所有的依赖注入容器,但是原生容器时没有问题的,Autofac应该也没有问题。




https://www.xamrdz.com/lan/5f21957266.html

相关文章: