提供服务注册描述信息来简化服务注册方式

　　asp.net core提供了依赖注入的支持，我们可以在Startup.ConfigureServices方法中注册系统所需要的服务映射关系，如services.TryAddScoped<TInterface, TImp>()，通过这样的方式可以完成一个服务注册，并在代码中可以通过注入的方式获取到TImp的实例。如果系统里需要的服务比较多，一个一个这样去注册，显然不是特别好的方法，如何简化注册的过程呢？我们可以制定一个规则，比如给服务定义增加特性描述信息，标识当前是一个需要注册的服务，然后通过反射解析方式获取到信息，并完成服务注册。或者把服务注册信息写到文件中，解析文件完成相同的过程。

　　首先我们先定义一个能够描述服务注册信息的一个类，定义如下：

public class ServiceRegisteDescriptor
{
      public Type ServiceType { get; set; }//服务类型，可以是接口，也可以是一个类
      public ServiceLifetime LifeTime { get; set; }//服务的生命周期类型
      public bool AllowMultipleImp { get; set; }//该服务器是否允许多个实现
      public Type Imp { get; set; }//指定特定的实现
      public Type[] GenericParameterTypes { get; set; }//如果该服务是一个泛型类型，可以指定注册的泛型参数具体类型是什么
}

　　描述信息类定义好了，下面我们需要提供获取ServiceRegisteDescriptor集合的方法，我们这里先定义一个IServiceRegisteDescriptorCollectionProvider接口，定义如下：

public interface IServiceRegisteDescriptorCollectionProvider
{
      ServiceRegisteDescriptorCollection ServiceRegisteDescriptors { get; }
}

　　这个接口包含一个ServiceRegisteDescriptors属性，它是一个ServiceRegisteDescriptorCollection类型，从这个名字上可以看出，ServiceRegisteDescriptorCollection表示的就是ServiceRegisteDescriptor集合，具体定义如下：

public class ServiceRegisteDescriptorCollection
{
        public ServiceRegisteDescriptorCollection(IReadOnlyList<ServiceRegisteDescriptor> items)
        {
            Items = items ?? throw new ArgumentNullException(nameof(items));
        }
        public IReadOnlyList<ServiceRegisteDescriptor> Items { get; private set; }
}

　　接口定义好了，那如何去实现它？我们前面提到，服务注册信息源可以是程序集反射信息，也可以是文件内容，甚至可以是数据库中的数据等等，为了满足信息源多样性的支持以及方便扩展的需求，我们抽象一个IServiceRegisteDescriptorProvider接口，定义如下：

　　 public interface IServiceRegisteDescriptorProvider
    {
        /// <summary>
        /// 排序号，建议自定义的Provider，order从1开始，系统默认提供的Provider是0
        /// </summary>
        int Order { get; }
        /// <summary>
        /// 从特定目标获取服务注册描述信息，放到ServiceRegisteDescriptorProviderContext中
        /// </summary>
        /// <param name="context"></param>
        void OnProvidersExecuting(ServiceRegisteDescriptorProviderContext context);
        /// <summary>
        /// 在该方法中可以对收集好的ServiceRegisteDescriptor集合进行修改，比如删除，替换等
        /// </summary>
        /// <param name="context"></param>
        void OnProvidersExecuted(ServiceRegisteDescriptorProviderContext context);
    }

　　这个接口的作用就是从特定目标获取信息，并转换成ServiceRegisteDescritor信息，放到我们一个ServiceRegisteDescriptorProviderContext中进行汇总，并且可以在OnProvidersExecuted中对结果进行修改。我们下面先实现一个从程序集中获取信息。从程序集中获取信息可以采用反射的方式，我们可以定义一个特性，反射的时候获取包含该特性的类型定义列表，然后根据特性提供的数据进行类型分析，最后得到一个服务映射列表。

　　实现方式说完了，下面就是具体实现了，那就先定义一个特性，定义如下：

　　[AttributeUsage(AttributeTargets.Class|AttributeTargets.Interface,AllowMultiple =true,Inherited =false)]
    public class ServiceRegisteDescriptorAttribute:Attribute
    {
        public ServiceRegisteDescriptorAttribute(ServiceLifetime lifetime)
        {
            LifeTime = lifetime;
        }
        public ServiceLifetime LifeTime { get; }
        public bool AllowMultipleImp { get; set; }
        public Type Imp { get; set; }
        public Type GenericType { get; set; }
    }

　　这个特性的定义跟ServiceRegisteDescriptor很类似，唯一不包含ServiceType属性，其他属性含义跟ServiceRegisteDescriptor一致。这个特性可以应用到类，接口上。有了特性定义，我们可以在需要完成注册的类型定义上增加该特性，比如：

　　[ServiceRegisteDescriptor(Microsoft.Extensions.DependencyInjection.ServiceLifetime.Singleton)]
    public interface IServiceTest
    {
        void TestM();
    }

　　这表示IServiceTest是一个需要注册的服务，我们从当前程序所包含的程序集中，获取到某个实现了该接口的类，建议一个服务映射关系。下面就是IServiceRegisteDescriptorProvider具体实现了。定义一个类DefaultServiceRegisterDescriptorProvider，实现IServiceRegisteDescriptorProvider接口，如下：

public class DefaultServiceRegisterDescriptorProvider : IServiceRegisteDescriptorProvider
{}

　　核心是OnProvidersExecuting方法，在这个方法中实现我们刚才说的反射解析过程，具体实现代码：

 public void OnProvidersExecuting(ServiceRegisteDescriptorProviderContext context)
        {
            //获取当前运行程序所有的程序集集合，一会再说AssemblyDisconvery实现
            Assembly[] assemblys = AssemblyDiscovery.Discovery();
            //得到所有包含ServiceRegisteDescriptorAttribute特性的类型集合
            IEnumerable<Type> types = assemblys.SelectMany(m => m.GetTypes().Where(t => t.GetTypeInfo().GetCustomAttributes().Any(a => a.GetType() == typeof(ServiceRegisteDescriptorAttribute)))).ToList();
            foreach (var type in types)
            {
                TypeInfo typeInfo = type.GetTypeInfo();
                //获取当前类型的ServiceRegisteDescriptorAttribute特性对象
                ServiceRegisteDescriptorAttribute attr = type.GetTypeInfo().GetCustomAttributes().FirstOrDefault(m => m.GetType() == typeof(ServiceRegisteDescriptorAttribute)) as ServiceRegisteDescriptorAttribute;
                //如果当前类型是一个泛型类型，必须执行GenericType
                if (typeInfo.IsGenericTypeDefinition && attr.GenericType == null)
                {
                    throw new NotSupportedException(nameof(attr));
                }
                //下面的过程是获取当前服务的实现类集合
                Type[] impTypes = null;
                if ((typeInfo.IsInterface || typeInfo.IsAbstract) && attr.Imp == null)
                {
                    //从程序集中获取所有实现了该服务端类
                    if (typeInfo.IsGenericTypeDefinition && typeInfo.IsInterface)
                    {
                        impTypes = assemblys.SelectMany(m => m.GetTypes().Where(t => t.GetTypeInfo().IsClass && !t.GetTypeInfo().IsAbstract && t.GetTypeInfo().GetInterfaces().Any(i => i.GetTypeInfo().IsGenericType && i.GetGenericTypeDefinition() == type))).ToArray();
                    }
                    else
                    {
                        if (typeInfo.IsInterface)
                        {
                            impTypes = assemblys.SelectMany(m => m.GetTypes().Where(t => t.GetTypeInfo().IsClass && !t.GetTypeInfo().IsAbstract && t.GetTypeInfo().GetInterfaces().Any(i => i == type))).ToArray();
                        }
                        else
                        {
                            impTypes = assemblys.SelectMany(m => m.GetTypes().Where(t => t.GetTypeInfo().IsClass && !t.GetTypeInfo().IsAbstract && t.GetTypeInfo().IsSubclassOf(type))).ToArray();
                        }
                    }
                }
　　　　　       else if (attr.Imp!=null)
　　　　　       {
　　　　　　　     impTypes = new Type[1] { attr.Imp };
　　　　　       }
                else
                {
                    impTypes = new Type[1] { type };
                }
                //建立映射关系
                foreach (var imp in impTypes)
                {
                    ServiceRegisteDescriptor d=new ServiceRegisteDescriptor
                    {
                        AllowMultipleImp = attr.AllowMultipleImp,
                        Imp = imp,
                        ServiceType = type,
                        LifeTime = attr.LifeTime
                    };
                    //如果是泛型类型，获取所有类型为attr.GenericType的类型集合，包含所有子孙类型
                    if (typeInfo.IsGenericType)
                    {
                        d.GenericParameterTypes = assemblys.SelectMany(m => m.GetTypes().Where(t => !t.GetTypeInfo().IsAbstract && (t.GetTypeInfo().IsSubclassOf(attr.GenericType) || t == attr.GenericType))).ToArray();
                    }
                    context.Results.Add(d);
                }
            }
        }

　　

　　

　　通过上面的方式，我们就能从程序集中获取所有的服务定义信息。前面使用了一个AssemblyDisconery获取程序集集合，它的实现如下：

　　public class AssemblyDiscovery
    {
        public static Assembly[] Discovery()
        {
           
            return DependencyContext.Default.RuntimeLibraries.SelectMany(l => l.GetDefaultAssemblyNames(DependencyContext.Default)).Select(Assembly.Load).ToArray();
        }
    }

　　AssemblyDiscovery使用DependencyContext来获取程序集集合。

　　上面是实现了从程序集中获取服务注册描述信息，如果源是文件呢？我们可以以xml或者json格式保存ServiceRegisteDescriptor配置集合，然后从文件中读取内容并按照特定格式解析，按照上面的分析过程，最终可以得到我们所需要的ServiceRegisteDescriptorCollection，如果源是数据库也一样，这些实现代码就不再提供了。

　　有了IServiceRegisteDescriptorProvider，我们可以调用所有IServiceRegisteDescriptorProvider对象的方法，完成信息收集，下面我们就实现IServiceRegisteDescriptorCollectionProvider，代码如下:

　　public class ServiceRegisteDescriptorCollectionProvider : IServiceRegisteDescriptorCollectionProvider
    {
        private readonly IServiceRegisteDescriptorProvider[] _serviceRegisteDescriptorProviders;
        private ServiceRegisteDescriptorCollection _collection;

        public ServiceRegisteDescriptorCollectionProvider(
           IEnumerable<IServiceRegisteDescriptorProvider> serviceRegisteDescriptorProviders)
        {
            _serviceRegisteDescriptorProviders = serviceRegisteDescriptorProviders
                .OrderBy(p => p.Order)
                .ToArray();
        }

        private void UpdateCollection()
        {
            var context = new ServiceRegisteDescriptorProviderContext();
            //循环所有的Provider完成解析
            for (var i = 0; i < _serviceRegisteDescriptorProviders.Length; i++)
            {
                _serviceRegisteDescriptorProviders[i].OnProvidersExecuting(context);
            }
            //这里完成ServiceRegisteDescriptor集合的修改
            for (var i = _serviceRegisteDescriptorProviders.Length - 1; i >= 0; i--)
            {
                _serviceRegisteDescriptorProviders[i].OnProvidersExecuted(context);
            }
            //生成集合
            _collection = new ServiceRegisteDescriptorCollection(
                new ReadOnlyCollection<ServiceRegisteDescriptor>(context.Results));
        }
        public ServiceRegisteDescriptorCollection ServiceRegisteDescriptors
        {
            get
            {
                if (_collection == null)
                {
                    UpdateCollection();
                }

                return _collection;
            }
        }

　　完成ServiceRegisteDescriptorCollection收集之后，下面就是注册到ServiceCollection中了，我们直接扩展IServiceCollection对象，代码如下：

　　public static class ServiceScanServiceCollectionExtensions
    {
       
        public static IServiceCollection AddScanServices(this IServiceCollection services)
        {
            return AddScanServices(services,null);
        }

        public static IServiceCollection AddScanServices(this IServiceCollection services,Action<ServiceScanOptions> options)
        {
            //提供自定义IServiceRegisteDescriptorProvider扩展的配置入口
            ServiceScanOptions option = new ServiceScanOptions();
            option.DescriptorProviderTypes.Add(new DefaultServiceRegisterDescriptorProvider());
            options?.Invoke(option);
            //获取集合
            IServiceRegisteDescriptorCollectionProvider provider = new ServiceRegisteDescriptorCollectionProvider(option.DescriptorProviderTypes);
            ServiceRegisteDescriptorCollection collection = provider.ServiceRegisteDescriptors;
            foreach (var item in collection.Items)
            {
                //完成注册
                ServiceRegister.Registe(services,item);
            }

            return services;
        }

　　

　　我们一个问题一个问题介绍，首先是ServiceScanOptions，这个是为了自定义IServiceRegisteDescriptorProvider扩展配置提供的类，代码如下：

　　public class ServiceScanOptions
    {
        public IList<IServiceRegisteDescriptorProvider> DescriptorProviderTypes { get; } = new List<IServiceRegisteDescriptorProvider>();
    }

　　通过上面的代码我们可以看出，我们通过调用IServiceCollectoin.AddScanServices方法时，利用Action<ServiceScanOptions>委托，可以把自定义的扩展加入到ServiceScanOptions.DescriptorProviderTypes中，系统默认提供的是DefaultServiceRegisterDescriptorProvider。

　　ServiceRegister.Registe方法是根据ServiceRegisteDescriptor把服务注册到IServiceCollectoin中，实现如下：

　　public class ServiceRegister
    {
        private static void RegisteItem(IServiceCollection services,ServiceLifetime lifeTime,Type serviceType,Type impType,bool allowMultipleImp)
        {
            ServiceDescriptor serviceDescriptor = null;
            switch (lifeTime)
            {
                case ServiceLifetime.Singleton:
                    serviceDescriptor = ServiceDescriptor.Singleton(serviceType, impType);
                    break;
                case ServiceLifetime.Scoped:
                    serviceDescriptor = ServiceDescriptor.Scoped(serviceType, impType);
                    break;
                case ServiceLifetime.Transient:
                    serviceDescriptor = ServiceDescriptor.Transient(serviceType, impType);
                    break;
            }
            if (allowMultipleImp)
            {
                services.TryAddEnumerable(serviceDescriptor);
            }
            else
            {
                services.TryAdd(serviceDescriptor);
            }
           
        }
        public static void Registe(IServiceCollection services,ServiceRegisteDescriptor descriptor)
        {
            //判断是否是泛型接口
            if (descriptor.ServiceType.GetTypeInfo().IsGenericType)
            {
                if (descriptor.GenericParameterTypes == null)
                {
                    throw new NullReferenceException(nameof(descriptor.GenericParameterTypes));
                }

                if (!descriptor.Imp.GetTypeInfo().IsGenericType)
                {
                    throw new NotSupportedException(nameof(descriptor.Imp));
                }
                //根据泛型类型注册服务
                foreach (var item in descriptor.GenericParameterTypes)
                {
                    RegisteItem(services,descriptor.LifeTime, descriptor.ServiceType.MakeGenericType(item), descriptor.Imp.MakeGenericType(item), descriptor.AllowMultipleImp);
                }
            }
            else
            {
                RegisteItem(services, descriptor.LifeTime, descriptor.ServiceType, descriptor.Imp,descriptor.AllowMultipleImp);
            }            
        }
    }

　　这里重点说下泛型的规则，比如定义了一个泛型接口如下：

　　[ServiceRegisteDescriptor(Microsoft.Extensions.DependencyInjection.ServiceLifetime.Scoped,AllowMultipleImp =true,GenericType =typeof(EntityTest))]
    public interface IGenericTest<T>
    {
        
    }

　　ServiceRegisteDescriptor表示当前是一个需要注册的服务，然后泛型参数类型为EntityTest，意思就是说所有EntityTest类型（包括所有子孙类型）都要注册一个IGnericTest<>服务，如下映射关系：

     IGenericTest<EntityTest>  -->  GenericTest<EntityTest>

     IGenericTest<EntityTest1>  --> GenericTest<EntityTest1>   EntityTest1派生自EntityTest

　　到这里就介绍完了，具体使用方法：　

　　1. 引入DepencencyInjectionScan库：Install-Package Microsoft.Extensions.DependencyInjection.Scan
　　2. 使用IServiceCollection.AddScanServices()完成服务注册
　　3. 自定义IServiceRegisteDescriptorProvider注册方法：IServiceCollection.AddScanServices(options=>{options.DescriptorProviderTypes.Add(对象);});

　　完整的实现代码也放到了github上，地址是：https://github.com/dxp909/DependencyInjectionScan.git，大家可以下载查看