AspectCore 在注册服务这块比较简单，默认是无法根据Name去注册和解析对象，这边做一下这块的扩展
大致原理是根据自定义Name去生成对应的动态类型，然后使用委托或者对象的方式，进行注册
tips:由于底层原理的原因，无法支持Type的方式进行注册
定义好动态类型的接口，以及相关实现
1 public interface INamedService : IDisposable
2 {
3 object Service { get; }
4 }
5
6 public interface INamedService<out T> : INamedService
7 where T : class
8 {
9 new T Service { get; }
10 }
11
12 public interface INamedService<out TService, TNamed> : INamedService<TService>
13 where TService : class
14 where TNamed : struct
15 {
16 }
17
18 internal class NamedService<TService, TNamed> : INamedService<TService, TNamed>
19 where TService : class
20 where TNamed : struct
21 {
22 ~NamedService()
23 {
24 Dispose(false);
25 }
26
27 public NamedService(TService service)
28 {
29 Service = service;
30 }
31
32 public TService Service { get; private set; }
33
34 object INamedService.Service => Service;
35
36 public void Dispose()
37 {
38 Dispose(true);
39 GC.SuppressFinalize(this);
40 }
41
42 private void Dispose(bool disposing)
43 {
44 if (!disposing)
45 {
46 return;
47 }
48
49 if (Service == null)
50 {
51 return;
52 }
53
54 if (Service is IDisposable disposable)
55 {
56 disposable.Dispose();
57 Service = null;
58 }
59 }
60 }
根据自定义Name和ServiceType生成对应的动态类型
1 public static class NamedBuilder
2 {
3 private const string KeyPrefix = "Ksd.NamedType.";
4 private static readonly ModuleBuilder _moduleBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("Ksd.DynamicAssembly.NamedType"), AssemblyBuilderAccess.Run).DefineDynamicModule("NamedTypeModule");
5 private static readonly ConcurrentDictionary<string, Type> _namedTypes = new(StringComparer.OrdinalIgnoreCase);
6
7 private static Type GetNamedType(string name)
8 {
9 if (name.IsNull())
10 {
11 throw new ArgumentNullException(nameof(name));
12 }
13
14 name = KeyPrefix + name;
15
16 return _namedTypes.GetOrAdd(name, k =>
17 {
18 var tb = _moduleBuilder.DefineType(k, TypeAttributes.Public | TypeAttributes.Sealed, typeof(ValueType));
19 var type = tb.CreateTypeInfo().AsType();
20 return type;
21 });
22 }
23
24 public static Type CreateServiceType(string name, Type serviceType)
25 {
26 var namedType = GetNamedType(name);
27 return typeof(NamedService<,>).MakeGenericType(serviceType, namedType);
28 }
29
30 public static Type CreateServiceBaseType(string name, Type serviceType)
31 {
32 var namedType = GetNamedType(name);
33 return typeof(INamedService<,>).MakeGenericType(serviceType, namedType);
34 }
35
36 public static Type GetNameServiceBaseType(Type namedType)
37 {
38 return namedType.GetInterfaces()[0];
39 }
40 }
封装根据自定义的Name注册和解析的相关方法
1 public static class NamedServiceExtensions
2 {
3 #region AddInstance
4 public static IServiceContext AddInstance(this IServiceContext services, Type serviceType, object implementationInstance, string name)
5 {
6 if (name.IsNull())
7 {
8 return services.AddInstance(serviceType, implementationInstance);
9 }
10
11 if (services == null)
12 {
13 throw new ArgumentNullException(nameof(services));
14 }
15
16 if (serviceType == null)
17 {
18 throw new ArgumentNullException(nameof(serviceType));
19 }
20
21 if (implementationInstance == null)
22 {
23 throw new ArgumentNullException(nameof(implementationInstance));
24 }
25
26 var namedType = NamedBuilder.CreateServiceType(name, serviceType);
27 services.AddInstance(NamedBuilder.GetNameServiceBaseType(namedType), Activator.CreateInstance(namedType, implementationInstance));
28 return services;
29 }
30
31 public static IServiceContext AddInstance<TService>(this IServiceContext services, TService implementationInstance, string name)
32 {
33 return services.AddInstance(typeof(TService), implementationInstance, name);
34 }
35 #endregion
36
37 #region AddDelegate
38 public static IServiceContext AddDelegate(this IServiceContext services, Type serviceType, Func<IServiceResolver, object> implementationDelegate, string name, Lifetime lifetime = Lifetime.Transient)
39 {
40 if (name.IsNull())
41 {
42 return services.AddDelegate(serviceType, implementationDelegate, lifetime);
43 }
44
45 if (services == null)
46 {
47 throw new ArgumentNullException(nameof(services));
48 }
49
50 if (serviceType == null)
51 {
52 throw new ArgumentNullException(nameof(serviceType));
53 }
54
55 if (implementationDelegate == null)
56 {
57 throw new ArgumentNullException(nameof(implementationDelegate));
58 }
59
60 var namedType = NamedBuilder.CreateServiceType(name, serviceType);
61 services.AddDelegate(NamedBuilder.GetNameServiceBaseType(namedType), s => Activator.CreateInstance(namedType, implementationDelegate(s)), lifetime);
62 return services;
63 }
64
65 public static IServiceContext AddDelegate<TService>(this IServiceContext services, Func<IServiceResolver, TService> implementationDelegate, string name, Lifetime lifetime = Lifetime.Transient)
66 where TService : class
67 {
68 return services.AddDelegate(typeof(TService), implementationDelegate, name, lifetime);
69 }
70 #endregion
71
72 #region Resolve
73 public static T Resolve<T>(this IServiceResolver serviceResolver, string name)
74 where T : class
75 {
76 if (name.IsNull())
77 {
78 return serviceResolver.Resolve<T>();
79 }
80
81 var namedType = NamedBuilder.CreateServiceBaseType(name, typeof(T));
82 var namedService = serviceResolver.Resolve(namedType) as INamedService<T>;
83 return namedService?.Service;
84 }
85
86 public static object Resolve(this IServiceResolver serviceResolver, Type serviceType, string name)
87 {
88 if (name.IsNull())
89 {
90 return serviceResolver.Resolve(serviceType);
91 }
92
93 var namedType = NamedBuilder.CreateServiceBaseType(name, serviceType);
94 var namedService = serviceResolver.Resolve(namedType) as INamedService;
95 return namedService?.Service;
96 }
97
98 public static IEnumerable<T> ResolveMany<T>(this IServiceResolver serviceResolver, string name)
99 where T : class
100 {
101 if (name.IsNull())
102 {
103 return serviceResolver.ResolveMany<T>();
104 }
105
106 var namedType = NamedBuilder.CreateServiceBaseType(name, typeof(T));
107 var namedServices = serviceResolver.ResolveMany(namedType).OfType<INamedService<T>>();
108 return namedServices.Select(t => t.Service);
109 }
110
111 public static IEnumerable<object> ResolveMany(this IServiceResolver serviceResolver, Type serviceType, string name)
112 {
113 if (name.IsNull())
114 {
115 return serviceResolver.ResolveMany(serviceType);
116 }
117
118 var namedType = NamedBuilder.CreateServiceBaseType(name, serviceType);
119 var namedServices = serviceResolver.ResolveMany(namedType) as IEnumerable<INamedService>;
120 return namedServices.Select(t => t.Service);
121 }
122 #endregion
123
124 #region Remove
125 public static IServiceContext RemoveAll(this IServiceContext services, Type serviceType, string name)
126 {
127 if (name.IsNull())
128 {
129 return services.RemoveAll(serviceType);
130 }
131
132 var namedType = NamedBuilder.CreateServiceBaseType(name, serviceType);
133 services.RemoveAll(namedType);
134 return services;
135 }
136
137 public static IServiceContext RemoveAll<T>(this IServiceContext services, string name)
138 where T : class
139 {
140 return services.RemoveAll(typeof(T), name);
141 }
142 #endregion
143
144 #region Other
145 public static bool Contains(this IServiceContext services, Type serviceType, string name)
146 {
147 if (name.IsNull())
148 {
149 return services.Contains(serviceType);
150 }
151
152 var namedType = NamedBuilder.CreateServiceBaseType(name, serviceType);
153 return services.Contains(namedType);
154 }
155 #endregion
156 }
根据以上原理，MSDI亦可作对应的注册以及解析方法
1 public static class NamedServiceExtensions
2 {
3 #region Add
4 public static IServiceCollection AddSingleton(this IServiceCollection services, Type serviceType, object implementationInstance, string name)
5 {
6 services.AddNamed(serviceType, _ => implementationInstance, name, ServiceLifetime.Singleton);
7 return services;
8 }
9
10 public static IServiceCollection AddSingleton<TService>(this IServiceCollection services, TService implementationInstance, string name)
11 where TService : class
12 {
13 return services.AddSingleton(typeof(TService), implementationInstance, name);
14 }
15
16 public static IServiceCollection AddSingleton(this IServiceCollection services, Type serviceType, Func<IServiceProvider, object> implementationFactory, string name)
17 {
18 services.AddNamed(serviceType, implementationFactory, name, ServiceLifetime.Singleton);
19 return services;
20 }
21
22 public static IServiceCollection AddSingleton<TService>(this IServiceCollection services, Func<IServiceProvider, TService> implementationFactory, string name)
23 where TService : class
24 {
25 return services.AddSingleton(typeof(TService), implementationFactory, name);
26 }
27
28 public static IServiceCollection AddScoped(this IServiceCollection services, Type serviceType, Func<IServiceProvider, object> implementationFactory, string name)
29 {
30 services.AddNamed(serviceType, implementationFactory, name, ServiceLifetime.Scoped);
31 return services;
32 }
33
34 public static IServiceCollection AddScoped<TService>(this IServiceCollection services, Func<IServiceProvider, TService> implementationFactory, string name)
35 where TService : class
36 {
37 return services.AddScoped(typeof(TService), implementationFactory, name);
38 }
39
40 public static IServiceCollection AddTransient(this IServiceCollection services, Type serviceType, Func<IServiceProvider, object> implementationFactory, string name)
41 {
42 services.AddNamed(serviceType, implementationFactory, name, ServiceLifetime.Transient);
43 return services;
44 }
45
46 public static IServiceCollection AddTransient<TService>(this IServiceCollection services, Func<IServiceProvider, TService> implementationFactory, string name)
47 where TService : class
48 {
49 return services.AddTransient(typeof(TService), implementationFactory, name);
50 }
51
52 public static IServiceCollection AddNamed(this IServiceCollection services, Type serviceType, Func<IServiceProvider, object> implementationFactory, string name, ServiceLifetime lifetime = ServiceLifetime.Transient)
53 {
54 if (name.IsNull())
55 {
56 services.Add(ServiceDescriptor.Describe(serviceType, implementationFactory, lifetime));
57 return services;
58 }
59
60 if (services == null)
61 {
62 throw new ArgumentNullException(nameof(services));
63 }
64
65 if (serviceType == null)
66 {
67 throw new ArgumentNullException(nameof(serviceType));
68 }
69
70 if (implementationFactory == null)
71 {
72 throw new ArgumentNullException(nameof(implementationFactory));
73 }
74
75 var namedType = NamedBuilder.CreateServiceType(name, serviceType);
76
77 services.Add(ServiceDescriptor.Describe(namedType, s => Activator.CreateInstance(namedType, implementationFactory(s)), lifetime));
78 return services;
79 }
80 #endregion
81
82 #region GetService
83 public static T GetService<T>(this IServiceProvider serviceProvider, string name)
84 where T : class
85 {
86 if (serviceProvider == null)
87 {
88 throw new ArgumentNullException(nameof(serviceProvider));
89 }
90
91 if (name.IsNull())
92 {
93 return serviceProvider.GetService<T>();
94 }
95
96 var namedType = NamedBuilder.CreateServiceBaseType(name, typeof(T));
97 var namedService = serviceProvider.GetService(namedType) as INamedService<T>;
98 return namedService?.Service;
99 }
100
101 public static object GetService(this IServiceProvider serviceProvider, Type serviceType, string name)
102 {
103 if (serviceProvider == null)
104 {
105 throw new ArgumentNullException(nameof(serviceProvider));
106 }
107
108 if (name.IsNull())
109 {
110 return serviceProvider.GetService(serviceType);
111 }
112
113 var namedType = NamedBuilder.CreateServiceBaseType(name, serviceType);
114 var namedService = serviceProvider.GetService(namedType) as INamedService;
115 return namedService?.Service;
116 }
117
118 public static IEnumerable<T> GetServices<T>(this IServiceProvider serviceProvider, string name)
119 where T : class
120 {
121 if (serviceProvider == null)
122 {
123 throw new ArgumentNullException(nameof(serviceProvider));
124 }
125
126 if (name.IsNull())
127 {
128 return serviceProvider.GetServices<T>();
129 }
130
131 var namedType = NamedBuilder.CreateServiceBaseType(name, typeof(T));
132 var namedServices = serviceProvider.GetServices(namedType) as IEnumerable<INamedService<T>>;
133 return namedServices.Select(t => t.Service);
134 }
135
136 public static IEnumerable<object> GetServices(this IServiceProvider serviceProvider, Type serviceType, string name)
137 {
138 if (serviceProvider == null)
139 {
140 throw new ArgumentNullException(nameof(serviceProvider));
141 }
142
143 if (name.IsNull())
144 {
145 return serviceProvider.GetServices(serviceType);
146 }
147
148 var namedType = NamedBuilder.CreateServiceBaseType(name, serviceType);
149 var namedServices = serviceProvider.GetServices(namedType) as IEnumerable<INamedService>;
150 return namedServices.Select(t => t.Service);
151 }
152 #endregion
153
154 #region Remove
155 public static IServiceCollection RemoveAll(this IServiceCollection services, Type serviceType, string name)
156 {
157 var namedType = NamedBuilder.CreateServiceBaseType(name, serviceType);
158 services.RemoveAll(namedType);
159 return services;
160 }
161
162 public static IServiceCollection RemoveAll<T>(this IServiceCollection services, string name)
163 {
164 return services.RemoveAll(typeof(T), name);
165 }
166 #endregion
167
168 #region Other
169 public static bool Contains(this IServiceCollection services, Type serviceType, string name)
170 {
171 if (name.IsNull())
172 {
173 return services.Contains(serviceType);
174 }
175
176 var namedType = NamedBuilder.CreateServiceBaseType(name, serviceType);
177 return services.Contains(namedType);
178 }
179 #endregion
180 }
