AspectCore和MSDI 实现Name注册以及解析对象

AspectCore 在注册服务这块比较简单，默认是无法根据Name去注册和解析对象，这边做一下这块的扩展

大致原理是根据自定义Name去生成对应的动态类型，然后使用委托或者对象的方式，进行注册

tips:由于底层原理的原因，无法支持Type的方式进行注册

 

定义好动态类型的接口，以及相关实现

public interface INamedService : IDisposable
{
    object Service { get; }
}

public interface INamedService<out T> : INamedService
    where T : class
{
    new T Service { get; }
}

public interface INamedService<out TService, TNamed> : INamedService
    where TService : class
    where TNamed : struct
{
}

internal class NamedService : INamedService
    where TService : class
    where TNamed : struct
{
    ~NamedService()
    {
        Dispose(false);
    }

    public NamedService(TService service)
    {
        Service = service;
    }

    public TService Service { get; private set; }

    object INamedService.Service => Service;

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    private void Dispose(bool disposing)
    {
        if (!disposing)
        {
            return;
        }

        if (Service == null)
        {
            return;
        }

        if (Service is IDisposable disposable)
        {
            disposable.Dispose();
            Service = null;
        }
    }
}

 

根据自定义Name和ServiceType生成对应的动态类型

public static class NamedBuilder
{
    private const string KeyPrefix = "Ksd.NamedType.";
    private static readonly ModuleBuilder _moduleBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("Ksd.DynamicAssembly.NamedType"), AssemblyBuilderAccess.Run).DefineDynamicModule("NamedTypeModule");
    private static readonly ConcurrentDictionary<string, Type> _namedTypes = new(StringComparer.OrdinalIgnoreCase);

    private static Type GetNamedType(string name)
    {
        if (name.IsNull())
        {
            throw new ArgumentNullException(nameof(name));
        }

        name = KeyPrefix + name;

        return _namedTypes.GetOrAdd(name, k =>
        {
            var tb = _moduleBuilder.DefineType(k, TypeAttributes.Public | TypeAttributes.Sealed, typeof(ValueType));
            var type = tb.CreateTypeInfo().AsType();
            return type;
        });
    }

    public static Type CreateServiceType(string name, Type serviceType)
    {
        var namedType = GetNamedType(name);
        return typeof(NamedService<,>).MakeGenericType(serviceType, namedType);
    }

    public static Type CreateServiceBaseType(string name, Type serviceType)
    {
        var namedType = GetNamedType(name);
        return typeof(INamedService<,>).MakeGenericType(serviceType, namedType);
    }

    public static Type GetNameServiceBaseType(Type namedType)
    {
        return namedType.GetInterfaces()[0];
    }
}

 

封装根据自定义的Name注册和解析的相关方法

public static class NamedServiceExtensions
{
    #region AddInstance
    public static IServiceContext AddInstance(this IServiceContext services, Type serviceType, object implementationInstance, string name)
    {
        if (name.IsNull())
        {
            return services.AddInstance(serviceType, implementationInstance);
        }

        if (services == null)
        {
            throw new ArgumentNullException(nameof(services));
        }

        if (serviceType == null)
        {
            throw new ArgumentNullException(nameof(serviceType));
        }

        if (implementationInstance == null)
        {
            throw new ArgumentNullException(nameof(implementationInstance));
        }

        var namedType = NamedBuilder.CreateServiceType(name, serviceType);
        services.AddInstance(NamedBuilder.GetNameServiceBaseType(namedType), Activator.CreateInstance(namedType, implementationInstance));
        return services;
    }

    public static IServiceContext AddInstance(this IServiceContext services, TService implementationInstance, string name)
    {
        return services.AddInstance(typeof(TService), implementationInstance, name);
    }
    #endregion

    #region AddDelegate
    public static IServiceContext AddDelegate(this IServiceContext services, Type serviceType, Funcobject> implementationDelegate, string name, Lifetime lifetime = Lifetime.Transient)
    {
        if (name.IsNull())
        {
            return services.AddDelegate(serviceType, implementationDelegate, lifetime);
        }

        if (services == null)
        {
            throw new ArgumentNullException(nameof(services));
        }

        if (serviceType == null)
        {
            throw new ArgumentNullException(nameof(serviceType));
        }

        if (implementationDelegate == null)
        {
            throw new ArgumentNullException(nameof(implementationDelegate));
        }

        var namedType = NamedBuilder.CreateServiceType(name, serviceType);
        services.AddDelegate(NamedBuilder.GetNameServiceBaseType(namedType), s => Activator.CreateInstance(namedType, implementationDelegate(s)), lifetime);
        return services;
    }

    public static IServiceContext AddDelegate(this IServiceContext services, Func implementationDelegate, string name, Lifetime lifetime = Lifetime.Transient)
        where TService : class
    {
        return services.AddDelegate(typeof(TService), implementationDelegate, name, lifetime);
    }
    #endregion

    #region Resolve
    public static T Resolve(this IServiceResolver serviceResolver, string name)
        where T : class
    {
        if (name.IsNull())
        {
            return serviceResolver.Resolve();
        }

        var namedType = NamedBuilder.CreateServiceBaseType(name, typeof(T));
        var namedService = serviceResolver.Resolve(namedType) as INamedService;
        return namedService?.Service;
    }

    public static object Resolve(this IServiceResolver serviceResolver, Type serviceType, string name)
    {
        if (name.IsNull())
        {
            return serviceResolver.Resolve(serviceType);
        }

        var namedType = NamedBuilder.CreateServiceBaseType(name, serviceType);
        var namedService = serviceResolver.Resolve(namedType) as INamedService;
        return namedService?.Service;
    }

    public static IEnumerable ResolveMany(this IServiceResolver serviceResolver, string name)
        where T : class
    {
        if (name.IsNull())
        {
            return serviceResolver.ResolveMany();
        }

        var namedType = NamedBuilder.CreateServiceBaseType(name, typeof(T));
        var namedServices = serviceResolver.ResolveMany(namedType).OfType>();
        return namedServices.Select(t => t.Service);
    }

    public static IEnumerable<object> ResolveMany(this IServiceResolver serviceResolver, Type serviceType, string name)
    {
        if (name.IsNull())
        {
            return serviceResolver.ResolveMany(serviceType);
        }

        var namedType = NamedBuilder.CreateServiceBaseType(name, serviceType);
        var namedServices = serviceResolver.ResolveMany(namedType) as IEnumerable;
        return namedServices.Select(t => t.Service);
    }
    #endregion

    #region Remove
    public static IServiceContext RemoveAll(this IServiceContext services, Type serviceType, string name)
    {
        if (name.IsNull())
        {
            return services.RemoveAll(serviceType);
        }

        var namedType = NamedBuilder.CreateServiceBaseType(name, serviceType);
        services.RemoveAll(namedType);
        return services;
    }

    public static IServiceContext RemoveAll(this IServiceContext services, string name)
        where T : class
    {
        return services.RemoveAll(typeof(T), name);
    }
    #endregion

    #region Other
    public static bool Contains(this IServiceContext services, Type serviceType, string name)
    {
        if (name.IsNull())
        {
            return services.Contains(serviceType);
        }

        var namedType = NamedBuilder.CreateServiceBaseType(name, serviceType);
        return services.Contains(namedType);
    }
    #endregion
}

 

根据以上原理，MSDI亦可作对应的注册以及解析方法

public static class NamedServiceExtensions
{
    #region Add
    public static IServiceCollection AddSingleton(this IServiceCollection services, Type serviceType, object implementationInstance, string name)
    {
        services.AddNamed(serviceType, _ => implementationInstance, name, ServiceLifetime.Singleton);
        return services;
    }

    public static IServiceCollection AddSingleton(this IServiceCollection services, TService implementationInstance, string name)
        where TService : class
    {
        return services.AddSingleton(typeof(TService), implementationInstance, name);
    }

    public static IServiceCollection AddSingleton(this IServiceCollection services, Type serviceType, Funcobject> implementationFactory, string name)
    {
        services.AddNamed(serviceType, implementationFactory, name, ServiceLifetime.Singleton);
        return services;
    }

    public static IServiceCollection AddSingleton(this IServiceCollection services, Func implementationFactory, string name)
        where TService : class
    {
        return services.AddSingleton(typeof(TService), implementationFactory, name);
    }

    public static IServiceCollection AddScoped(this IServiceCollection services, Type serviceType, Funcobject> implementationFactory, string name)
    {
        services.AddNamed(serviceType, implementationFactory, name, ServiceLifetime.Scoped);
        return services;
    }

    public static IServiceCollection AddScoped(this IServiceCollection services, Func implementationFactory, string name)
        where TService : class
    {
        return services.AddScoped(typeof(TService), implementationFactory, name);
    }

    public static IServiceCollection AddTransient(this IServiceCollection services, Type serviceType, Funcobject> implementationFactory, string name)
    {
        services.AddNamed(serviceType, implementationFactory, name, ServiceLifetime.Transient);
        return services;
    }

    public static IServiceCollection AddTransient(this IServiceCollection services, Func implementationFactory, string name)
        where TService : class
    {
        return services.AddTransient(typeof(TService), implementationFactory, name);
    }

    public static IServiceCollection AddNamed(this IServiceCollection services, Type serviceType, Funcobject> implementationFactory, string name, ServiceLifetime lifetime = ServiceLifetime.Transient)
    {
        if (name.IsNull())
        {
            services.Add(ServiceDescriptor.Describe(serviceType, implementationFactory, lifetime));
            return services;
        }

        if (services == null)
        {
            throw new ArgumentNullException(nameof(services));
        }

        if (serviceType == null)
        {
            throw new ArgumentNullException(nameof(serviceType));
        }

        if (implementationFactory == null)
        {
            throw new ArgumentNullException(nameof(implementationFactory));
        }

        var namedType = NamedBuilder.CreateServiceType(name, serviceType);

        services.Add(ServiceDescriptor.Describe(namedType, s => Activator.CreateInstance(namedType, implementationFactory(s)), lifetime));
        return services;
    }
    #endregion

    #region GetService
    public static T GetService(this IServiceProvider serviceProvider, string name)
        where T : class
    {
        if (serviceProvider == null)
        {
            throw new ArgumentNullException(nameof(serviceProvider));
        }

        if (name.IsNull())
        {
            return serviceProvider.GetService();
        }

        var namedType = NamedBuilder.CreateServiceBaseType(name, typeof(T));
        var namedService = serviceProvider.GetService(namedType) as INamedService;
        return namedService?.Service;
    }

    public static object GetService(this IServiceProvider serviceProvider, Type serviceType, string name)
    {
        if (serviceProvider == null)
        {
            throw new ArgumentNullException(nameof(serviceProvider));
        }

        if (name.IsNull())
        {
            return serviceProvider.GetService(serviceType);
        }

        var namedType = NamedBuilder.CreateServiceBaseType(name, serviceType);
        var namedService = serviceProvider.GetService(namedType) as INamedService;
        return namedService?.Service;
    }

    public static IEnumerable GetServices(this IServiceProvider serviceProvider, string name)
        where T : class
    {
        if (serviceProvider == null)
        {
            throw new ArgumentNullException(nameof(serviceProvider));
        }

        if (name.IsNull())
        {
            return serviceProvider.GetServices();
        }

        var namedType = NamedBuilder.CreateServiceBaseType(name, typeof(T));
        var namedServices = serviceProvider.GetServices(namedType) as IEnumerable>;
        return namedServices.Select(t => t.Service);
    }

    public static IEnumerable<object> GetServices(this IServiceProvider serviceProvider, Type serviceType, string name)
    {
        if (serviceProvider == null)
        {
            throw new ArgumentNullException(nameof(serviceProvider));
        }

        if (name.IsNull())
        {
            return serviceProvider.GetServices(serviceType);
        }

        var namedType = NamedBuilder.CreateServiceBaseType(name, serviceType);
        var namedServices = serviceProvider.GetServices(namedType) as IEnumerable;
        return namedServices.Select(t => t.Service);
    }
    #endregion

    #region Remove
    public static IServiceCollection RemoveAll(this IServiceCollection services, Type serviceType, string name)
    {
        var namedType = NamedBuilder.CreateServiceBaseType(name, serviceType);
        services.RemoveAll(namedType);
        return services;
    }

    public static IServiceCollection RemoveAll(this IServiceCollection services, string name)
    {
        return services.RemoveAll(typeof(T), name);
    }
    #endregion

    #region Other
    public static bool Contains(this IServiceCollection services, Type serviceType, string name)
    {
        if (name.IsNull())
        {
            return services.Contains(serviceType);
        }

        var namedType = NamedBuilder.CreateServiceBaseType(name, serviceType);
        return services.Contains(namedType);
    }
    #endregion
}