通过反射实现Netcore的服务依赖注入

先定义一个Attribute

using System;

namespace FireCloud.Framework
{
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = true)]
    public class InjectionAttribute: Attribute
    {
        public InjectionAttribute(Type name, Microsoft.Extensions.DependencyInjection.ServiceLifetime serviceLifetime)
        {
            Name = name;
            ServiceLifetime = serviceLifetime;
        }

        public Type Name { get; set; }

        public Microsoft.Extensions.DependencyInjection.ServiceLifetime ServiceLifetime { get; set; } 
    }
}

然后定义一个服务扩展方法

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Linq;
using System.Reflection;

namespace FireCloud.Framework
{
    public static class InjectionExtension
    {
        public static IServiceCollection AddInjections(this IServiceCollection services, IConfiguration configuration)
        {
            //配置文件获取注入的类库
            var injections = configuration.GetSection("Injection").GetChildren();
            if(injections != null && injections.Count() > 0)
            {
                foreach(var injection in injections)
                {
                    var assembly = Assembly.LoadFrom(AppDomain.CurrentDomain.BaseDirectory + injection.Value);
                    var types = assembly.GetTypes();
                    if(types != null && types.Length > 0)
                    {
                        foreach(var type in types)
                        {
                            var attribute = type.GetCustomAttribute(typeof(InjectionAttribute), false);
                            if (attribute is InjectionAttribute)
                            {
                                InjectionAttribute injectionAttribute = attribute as InjectionAttribute;
                                var name = injectionAttribute.Name;
                                var serviceLifetime = injectionAttribute.ServiceLifetime;
                                services = AddInjectionWithLifetime(services, serviceLifetime, name, type);
                            }
                        }
                    }
                }
            }
            return services;
        }

        private static IServiceCollection AddInjectionWithLifetime(IServiceCollection services, ServiceLifetime serviceLifetime, Type type, Type implementation)
        {
            switch (serviceLifetime)
            {
                case ServiceLifetime.Scoped:
                    return services.AddScoped(type, implementation);
                case ServiceLifetime.Singleton:
                    return services.AddSingleton(type, implementation);
                case ServiceLifetime.Transient:
                    return services.AddTransient(type, implementation);
                default:
                    return services;
            }
        }
    }
}

然后在服务的实现上面添加注入特性

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;

namespace FireCloud.Framework.Services
{
    [Injection(typeof(IConsulClientServices), Microsoft.Extensions.DependencyInjection.ServiceLifetime.Scoped)]
    public class ConsulClientServices : IConsulClientServices
    {
        public Task<T> PostData<T>(HttpClient _client, string actionUrl, Dictionary<string, object> dic)
        {
            throw new NotImplementedException();
        }
    }
}

appsettings配置文件的需要添加使用到的dll

"Injection": [
    "FireCloud.Framework.dll",
    "FireCloud.Web.dll"
  ]

最后是startup.cs里面的服务调用

public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR();
    services.AddControllers();
    //services.AddScoped<IConsulClientServices, ConsulClientServices>();
    services.Configure<Theme>(Configuration.GetSection("Theme"));
    services.AddInjections(Configuration);
}

建议把定义的特性，扩展方法放在Infrastructure层，因为可以全局引用

 个人demo，仅供参考。可以运行试试

原理就是根据appsettings里面配置的dll，拼接运行路径，生成dll的绝对路径，然后通过反射获取dll里面的类型，判断类型的自定义特性，获取名称和注入周期，然后写进服务注册里面