动手造轮子：实现一个简单的依赖注入(一)

当前位置:

首页 > temp > 简明python教程 >

动手造轮子：实现一个简单的依赖注入(一)

在上一篇文章中主要介绍了一下要做的依赖注入的整体设计和大概编程体验，这篇文章要开始写代码了，开始实现自己的依赖注入框架。

类图#

首先来温习一下上次提到的 UML 类图

服务生命周期#

服务生命周期定义：

Copy

public enum ServiceLifetime : sbyte { /// <summary> /// Specifies that a single instance of the service will be created. /// </summary> Singleton = 0, /// <summary> /// Specifies that a new instance of the service will be created for each scope. /// </summary> Scoped = 1, /// <summary> /// Specifies that a new instance of the service will be created every time it is requested. /// </summary> Transient = 2, }

服务定义#

服务注册定义：

Copy

public class ServiceDefinition { // 服务生命周期 public ServiceLifetime ServiceLifetime { get; } // 实现类型 public Type ImplementType { get; } // 服务类型 public Type ServiceType { get; } // 实现实例 public object ImplementationInstance { get; } // 实现工厂 public Func<IServiceProvider, object> ImplementationFactory { get; } // 获取真实的实现类型 public Type GetImplementType() { if (ImplementationInstance != null) return ImplementationInstance.GetType(); if (ImplementationFactory != null) return ImplementationFactory.Method.DeclaringType; if (ImplementType != null) return ImplementType; return ServiceType; } public ServiceDefinition(object instance, Type serviceType) { ImplementationInstance = instance; ServiceType = serviceType; ServiceLifetime = ServiceLifetime.Singleton; } public ServiceDefinition(Type serviceType, ServiceLifetime serviceLifetime) : this(serviceType, serviceType, serviceLifetime) { } public ServiceDefinition(Type serviceType, Type implementType, ServiceLifetime serviceLifetime) { ServiceType = serviceType; ImplementType = implementType ?? serviceType; ServiceLifetime = serviceLifetime; } public ServiceDefinition(Type serviceType, Func<IServiceProvider, object> factory, ServiceLifetime serviceLifetime) { ServiceType = serviceType; ImplementationFactory = factory; ServiceLifetime = serviceLifetime; } }

为了使用起来更方便添加了一些静态方法

Copy

public static ServiceDefinition Singleton<TService>(Func<IServiceProvider, object> factory) { return new ServiceDefinition(typeof(TService), factory, ServiceLifetime.Singleton); } public static ServiceDefinition Scoped<TService>(Func<IServiceProvider, object> factory) { return new ServiceDefinition(typeof(TService), factory, ServiceLifetime.Scoped); } public static ServiceDefinition Transient<TService>(Func<IServiceProvider, object> factory) { return new ServiceDefinition(typeof(TService), factory, ServiceLifetime.Transient); } public static ServiceDefinition Singleton<TService>() { return new ServiceDefinition(typeof(TService), ServiceLifetime.Singleton); } public static ServiceDefinition Scoped<TService>() { return new ServiceDefinition(typeof(TService), ServiceLifetime.Scoped); } public static ServiceDefinition Transient<TService>() { return new ServiceDefinition(typeof(TService), ServiceLifetime.Transient); } public static ServiceDefinition Singleton<TService, TServiceImplement>() where TServiceImplement : TService { return new ServiceDefinition(typeof(TService), typeof(TServiceImplement), ServiceLifetime.Singleton); } public static ServiceDefinition Scoped<TService, TServiceImplement>() where TServiceImplement : TService { return new ServiceDefinition(typeof(TService), typeof(TServiceImplement), ServiceLifetime.Scoped); } public static ServiceDefinition Transient<TService, TServiceImplement>() where TServiceImplement : TService { return new ServiceDefinition(typeof(TService), typeof(TServiceImplement), ServiceLifetime.Transient); }

ServiceContainer#

serviceContainer v1#

Copy

public class ServiceContainer : IServiceContainer { internal readonly List<ServiceDefinition> _services; private readonly ConcurrentDictionary<Type, object> _singletonInstances; private readonly ConcurrentDictionary<Type, object> _scopedInstances; private readonly List<object> _transientDisposables = new List<object>(); private readonly bool _isRootScope; public ServiceContainer() { _isRootScope = true; _singletonInstances = new ConcurrentDictionary<Type, object>(); _services = new List<ServiceDefinition>(); } internal ServiceContainer(ServiceContainer serviceContainer) { _isRootScope = false; _singletonInstances = serviceContainer._singletonInstances; _services = serviceContainer._services; _scopedInstances = new ConcurrentDictionary<Type, object>(); } public void Add(ServiceDefinition item) { _services.Add(item); } public IServiceContainer CreateScope() { return new ServiceContainer(this); } private bool _disposed; public void Dispose() { if (_disposed) { return; } if (_isRootScope) { lock (_singletonInstances) { if (_disposed) { return; } _disposed = true; foreach (var instance in _singletonInstances.Values) { (instance as IDisposable)?.Dispose(); } foreach (var o in _transientDisposables) { (o as IDisposable)?.Dispose(); } } } else { lock (_scopedInstances) { if (_disposed) { return; } _disposed = true; foreach (var instance in _scopedInstances.Values) { (instance as IDisposable)?.Dispose(); } foreach (var o in _transientDisposables) { (o as IDisposable)?.Dispose(); } } } } private object GetServiceInstance(Type serviceType, ServiceDefinition serviceDefinition) { if (serviceDefinition.ImplementationInstance != null) return serviceDefinition.ImplementationInstance; if (serviceDefinition.ImplementationFactory != null) return serviceDefinition.ImplementationFactory.Invoke(this); var implementType = (serviceDefinition.ImplementType ?? serviceType); if (implementType.IsInterface || implementType.IsAbstract) { throw new InvalidOperationException($"invalid service registered, serviceType: {serviceType.FullName}, implementType: {serviceDefinition.ImplementType}"); } var ctorInfos = implementType.GetConstructors(BindingFlags.Instance | BindingFlags.Public); if (ctorInfos.Length == 0) { throw new InvalidOperationException($"service {serviceType.FullName} does not have any public constructors"); } ConstructorInfo ctor; if (ctorInfos.Length == 1) { ctor = ctorInfos[0]; } else { // try find best ctor ctor = ctorInfos .OrderBy(_ => _.GetParameters().Length) .First(); } var parameters = ctor.GetParameters(); if (parameters.Length == 0) { // TODO: cache New Func return Expression.Lambda<Func<object>>(Expression.New(ctor)).Compile().Invoke(); } else { var ctorParams = new object[parameters.Length]; for (var index = 0; index < parameters.Length; index++) { var parameter = parameters[index]; var param = GetService(parameter.ParameterType); if (param == null && parameter.HasDefaultValue) { param = parameter.DefaultValue; } ctorParams[index] = param; } return Expression.Lambda<Func<object>>(Expression.New(ctor, ctorParams.Select(Expression.Constant))).Compile().Invoke(); } } public object GetService(Type serviceType) { var serviceDefinition = _services.LastOrDefault(_ => _.ServiceType == serviceType); if (null == serviceDefinition) { return null; } if (_isRootScope && serviceDefinition.ServiceLifetime == ServiceLifetime.Scoped) { throw new InvalidOperationException($"can not get scope service from the root scope, serviceType: {serviceType.FullName}"); } if (serviceDefinition.ServiceLifetime == ServiceLifetime.Singleton) { var svc = _singletonInstances.GetOrAdd(serviceType, (t) => GetServiceInstance(t, serviceDefinition)); return svc; } else if (serviceDefinition.ServiceLifetime == ServiceLifetime.Scoped) { var svc = _scopedInstances.GetOrAdd(serviceType, (t) => GetServiceInstance(t, serviceDefinition)); return svc; } else { var svc = GetServiceInstance(serviceType, serviceDefinition); if (svc is IDisposable) { _transientDisposables.Add(svc); } return svc; } } }

为了使得服务注册更加方便，可以写一些扩展方法来方便注册：

Copy

public static IServiceContainer AddSingleton<TService>([NotNull]this IServiceContainer serviceContainer, [NotNull]TService service) { serviceContainer.Add(new ServiceDefinition(service, typeof(TService))); return serviceContainer; } public static IServiceContainer AddSingleton([NotNull]this IServiceContainer serviceContainer, [NotNull]Type serviceType) { serviceContainer.Add(new ServiceDefinition(serviceType, ServiceLifetime.Singleton)); return serviceContainer; } public static IServiceContainer AddSingleton([NotNull]this IServiceContainer serviceContainer, [NotNull]Type serviceType, [NotNull]Type implementType) { serviceContainer.Add(new ServiceDefinition(serviceType, implementType, ServiceLifetime.Singleton)); return serviceContainer; } public static IServiceContainer AddSingleton<TService>([NotNull]this IServiceContainer serviceContainer, [NotNull]Func<IServiceProvider, object> func) { serviceContainer.Add(ServiceDefinition.Singleton<TService>(func)); return serviceContainer; } public static IServiceContainer AddSingleton<TService>([NotNull]this IServiceContainer serviceContainer) { serviceContainer.Add(ServiceDefinition.Singleton<TService>()); return serviceContainer; } public static IServiceContainer AddSingleton<TService, TServiceImplement>([NotNull]this IServiceContainer serviceContainer) where TServiceImplement : TService { serviceContainer.Add(ServiceDefinition.Singleton<TService, TServiceImplement>()); return serviceContainer; } public static IServiceContainer AddScoped([NotNull]this IServiceContainer serviceContainer, [NotNull]Type serviceType) { serviceContainer.Add(new ServiceDefinition(serviceType, ServiceLifetime.Scoped)); return serviceContainer; } public static IServiceContainer AddScoped([NotNull]this IServiceContainer serviceContainer, [NotNull]Type serviceType, [NotNull]Type implementType) { serviceContainer.Add(new ServiceDefinition(serviceType, implementType, ServiceLifetime.Scoped)); return serviceContainer; } public static IServiceContainer AddScoped<TService>([NotNull]this IServiceContainer serviceContainer, [NotNull]Func<IServiceProvider, object> func) { serviceContainer.Add(ServiceDefinition.Scoped<TService>(func)); return serviceContainer; } public static IServiceContainer AddScoped<TService>([NotNull]this IServiceContainer serviceContainer) { serviceContainer.Add(ServiceDefinition.Scoped<TService>()); return serviceContainer; } public static IServiceContainer AddScoped<TService, TServiceImplement>([NotNull]this IServiceContainer serviceContainer) where TServiceImplement : TService { serviceContainer.Add(ServiceDefinition.Scoped<TService, TServiceImplement>()); return serviceContainer; } public static IServiceContainer AddTransient([NotNull]this IServiceContainer serviceContainer, [NotNull]Type serviceType) { serviceContainer.Add(new ServiceDefinition(serviceType, ServiceLifetime.Transient)); return serviceContainer; } public static IServiceContainer AddTransient([NotNull]this IServiceContainer serviceContainer, [NotNull]Type serviceType, [NotNull]Type implementType) { serviceContainer.Add(new ServiceDefinition(serviceType, implementType, ServiceLifetime.Transient)); return serviceContainer; } public static IServiceContainer AddTransient<TService>([NotNull]this IServiceContainer serviceContainer, [NotNull]Func<IServiceProvider, object> func) { serviceContainer.Add(ServiceDefinition.Transient<TService>(func)); return serviceContainer; } public static IServiceContainer AddTransient<TService>([NotNull]this IServiceContainer serviceContainer) { serviceContainer.Add(ServiceDefinition.Transient<TService>()); return serviceContainer; } public static IServiceContainer AddTransient<TService, TServiceImplement>([NotNull]this IServiceContainer serviceContainer) where TServiceImplement : TService { serviceContainer.Add(ServiceDefinition.Transient<TService, TServiceImplement>()); return serviceContainer; }

通过上面的代码就可以实现基本依赖注入了，但是从功能上来说，上面的代码只支持获取单个服务的实例，不支持注册一个接口的多个实现，获取接口的所有实现，为此对 ServiceContainer 中的 Instance 的 ConcurrentDictionary 的 Key 进行一下改造，使得可以能够以接口类型和实现类型联合作为 key，为此就有了第二版的 ServiceContainer

`ServiceContainer` v2#

为此定义了一个 ServiceKey 的类型，请注意这里一定要重写 GetHashCode 方法：

Copy

private class ServiceKey : IEquatable<ServiceKey> { public Type ServiceType { get; } public Type ImplementType { get; } public ServiceKey(Type serviceType, ServiceDefinition definition) { ServiceType = serviceType; ImplementType = definition.GetImplementType(); } public bool Equals(ServiceKey other) { return ServiceType == other?.ServiceType && ImplementType == other?.ImplementType; } public override bool Equals(object obj) { return Equals((ServiceKey)obj); } public override int GetHashCode() { var key = $"{ServiceType.FullName}_{ImplementType.FullName}"; return key.GetHashCode(); } }

第二版的 ServiceContainer :

Copy

public class ServiceContainer : IServiceContainer { internal readonly ConcurrentBag<ServiceDefinition> _services; private readonly ConcurrentDictionary<ServiceKey, object> _singletonInstances; private readonly ConcurrentDictionary<ServiceKey, object> _scopedInstances; private ConcurrentBag<object> _transientDisposables = new ConcurrentBag<object>(); private class ServiceKey : IEquatable<ServiceKey> { public Type ServiceType { get; } public Type ImplementType { get; } public ServiceKey(Type serviceType, ServiceDefinition definition) { ServiceType = serviceType; ImplementType = definition.GetImplementType(); } public bool Equals(ServiceKey other) { return ServiceType == other?.ServiceType && ImplementType == other?.ImplementType; } public override bool Equals(object obj) { return Equals((ServiceKey)obj); } public override int GetHashCode() { var key = $"{ServiceType.FullName}_{ImplementType.FullName}"; return key.GetHashCode(); } } private readonly bool _isRootScope; public ServiceContainer() { _isRootScope = true; _singletonInstances = new ConcurrentDictionary<ServiceKey, object>(); _services = new ConcurrentBag<ServiceDefinition>(); } private ServiceContainer(ServiceContainer serviceContainer) { _isRootScope = false; _singletonInstances = serviceContainer._singletonInstances; _services = serviceContainer._services; _scopedInstances = new ConcurrentDictionary<ServiceKey, object>(); } public IServiceContainer Add(ServiceDefinition item) { if (_disposed) { throw new InvalidOperationException("the service container had been disposed"); } if (_services.Any(_ => _.ServiceType == item.ServiceType && _.GetImplementType() == item.GetImplementType())) { return this; } _services.Add(item); return this; } public IServiceContainer TryAdd(ServiceDefinition item) { if (_disposed) { throw new InvalidOperationException("the service container had been disposed"); } if (_services.Any(_ => _.ServiceType == item.ServiceType)) { return this; } _services.Add(item); return this; } public IServiceContainer CreateScope() { return new ServiceContainer(this); } private bool _disposed; public void Dispose() { if (_disposed) { return; } if (_isRootScope) { lock (_singletonInstances) { if (_disposed) { return; } _disposed = true; foreach (var instance in _singletonInstances.Values) { (instance as IDisposable)?.Dispose(); } foreach (var o in _transientDisposables) { (o as IDisposable)?.Dispose(); } _singletonInstances.Clear(); _transientDisposables = null; } } else { lock (_scopedInstances) { if (_disposed) { return; } _disposed = true; foreach (var instance in _scopedInstances.Values) { (instance as IDisposable)?.Dispose(); } foreach (var o in _transientDisposables) { (o as IDisposable)?.Dispose(); } _scopedInstances.Clear(); _transientDisposables = null; } } } private object GetServiceInstance(Type serviceType, ServiceDefinition serviceDefinition) { if (serviceDefinition.ImplementationInstance != null) return serviceDefinition.ImplementationInstance; if (serviceDefinition.ImplementationFactory != null) return serviceDefinition.ImplementationFactory.Invoke(this); var implementType = (serviceDefinition.ImplementType ?? serviceType); if (implementType.IsInterface || implementType.IsAbstract) { throw new InvalidOperationException($"invalid service registered, serviceType: {serviceType.FullName}, implementType: {serviceDefinition.ImplementType}"); } if (implementType.IsGenericType) { implementType = implementType.MakeGenericType(serviceType.GetGenericArguments()); } var ctorInfos = implementType.GetConstructors(BindingFlags.Instance | BindingFlags.Public); if (ctorInfos.Length == 0) { throw new InvalidOperationException($"service {serviceType.FullName} does not have any public constructors"); } ConstructorInfo ctor; if (ctorInfos.Length == 1) { ctor = ctorInfos[0]; } else { // TODO: try find best ctor ctor = ctorInfos .OrderBy(_ => _.GetParameters().Length) .First(); } var parameters = ctor.GetParameters(); if (parameters.Length == 0) { // TODO: cache New Func return Expression.Lambda<Func<object>>(Expression.New(ctor)).Compile().Invoke(); } else { var ctorParams = new object[parameters.Length]; for (var index = 0; index < parameters.Length; index++) { var parameter = parameters[index]; var param = GetService(parameter.ParameterType); if (param == null && parameter.HasDefaultValue) { param = parameter.DefaultValue; } ctorParams[index] = param; } return Expression.Lambda<Func<object>>(Expression.New(ctor, ctorParams.Select(Expression.Constant))).Compile().Invoke(); } } public object GetService(Type serviceType) { if (_disposed) { throw new InvalidOperationException($"can not get scope service from a disposed scope, serviceType: {serviceType.FullName}"); } var serviceDefinition = _services.LastOrDefault(_ => _.ServiceType == serviceType); if (null == serviceDefinition) { if (serviceType.IsGenericType) { var genericType = serviceType.GetGenericTypeDefinition(); serviceDefinition = _services.LastOrDefault(_ => _.ServiceType == genericType); if (null == serviceDefinition) { var innerServiceType = serviceType.GetGenericArguments().First(); if (typeof(IEnumerable<>).MakeGenericType(innerServiceType) .IsAssignableFrom(serviceType)) { var innerRegType = innerServiceType; if (innerServiceType.IsGenericType) { innerRegType = innerServiceType.GetGenericTypeDefinition(); } // var list = new List<object>(4); foreach (var def in _services.Where(_ => _.ServiceType == innerRegType)) { object svc; if (def.ServiceLifetime == ServiceLifetime.Singleton) { svc = _singletonInstances.GetOrAdd(new ServiceKey(innerServiceType, def), (t) => GetServiceInstance(innerServiceType, def)); } else if (def.ServiceLifetime == ServiceLifetime.Scoped) { svc = _scopedInstances.GetOrAdd(new ServiceKey(innerServiceType, def), (t) => GetServiceInstance(innerServiceType, def)); } else { svc = GetServiceInstance(innerServiceType, def); if (svc is IDisposable) { _transientDisposables.Add(svc); } } if (null != svc) { list.Add(svc); } } var methodInfo = typeof(Enumerable) .GetMethod("Cast", BindingFlags.Static | BindingFlags.Public); if (methodInfo != null) { var genericMethod = methodInfo.MakeGenericMethod(innerServiceType); var castedValue = genericMethod.Invoke(null, new object[] { list }); if (typeof(IEnumerable<>).MakeGenericType(innerServiceType) == serviceType) { return castedValue; } var toArrayMethod = typeof(Enumerable).GetMethod("ToArray", BindingFlags.Static | BindingFlags.Public) .MakeGenericMethod(innerServiceType); return toArrayMethod.Invoke(null, new object[] { castedValue }); } return list; } return null; } } else { return null; } } if (_isRootScope && serviceDefinition.ServiceLifetime == ServiceLifetime.Scoped) { throw new InvalidOperationException($"can not get scope service from the root scope, serviceType: {serviceType.FullName}"); } if (serviceDefinition.ServiceLifetime == ServiceLifetime.Singleton) { var svc = _singletonInstances.GetOrAdd(new ServiceKey(serviceType, serviceDefinition), (t) => GetServiceInstance(t.ServiceType, serviceDefinition)); return svc; } else if (serviceDefinition.ServiceLifetime == ServiceLifetime.Scoped) { var svc = _scopedInstances.GetOrAdd(new ServiceKey(serviceType, serviceDefinition), (t) => GetServiceInstance(t.ServiceType, serviceDefinition)); return svc; } else { var svc = GetServiceInstance(serviceType, serviceDefinition); if (svc is IDisposable) { _transientDisposables.Add(svc); } return svc; } } }

这样我们就不仅支持了 IEnumerable<TService> 的注册，也支持 IReadOnlyList<TService>/ IReadOnlyCollection<TService> 的注册

因为 GetService 返回是 object , 不是强类型的，所以为了使用起来方便，定义了几个扩展方法，类似于微软的依赖注入框架里的 GetService<TService>()/GetServices<TService>()/GetRequiredService<TService>()

Copy

/// <summary> /// ResolveService /// </summary> /// <typeparam name="TService">TService</typeparam> /// <param name="serviceProvider">serviceProvider</param> /// <returns></returns> public static TService ResolveService<TService>([NotNull]this IServiceProvider serviceProvider) => (TService)serviceProvider.GetService(typeof(TService)); /// <summary>


  
  
   
    共2页: 
上一页
1
2
下一页


 
 
  
 
 
  

  
 
 
 
栏目列表
  
      
      简明python教程
      
      C#教程
      
      JavaScript教程
      
      
      
      
    
    
    

    
    
    


 




 





 



 






 




 
  
 
         
    最新更新
        

    
                      
              nodejs爬虫
     
Python正则表达式完全指南
     
爬取豆瓣Top250图书数据
     
shp 地图文件批量添加字段
     
爬虫小试牛刀（爬取学校通知公告）
     
【python基础】函数-初识函数
     
【python基础】函数-返回值
     
HTTP请求：requests模块基础使用必知必会
     
Python初学者友好丨详解参数传递类型
     
如何有效管理爬虫流量？
     



    
                  2个场景实例讲解GaussDB(DWS)基表统计信息估
     
常用的 SQL Server 关键字及其含义
     
动手分析SQL Server中的事务中使用的锁
     
openGauss内核分析：SQL by pass & 经典执行
     
一招教你如何高效批量导入与更新数据
     
天天写SQL，这些神奇的特性你知道吗？
     
openGauss内核分析：执行计划生成
     
[IM002]Navicat ODBC驱动器管理器 未发现数据
     
初入Sql Server 之 存储过程的简单使用
     
SQL Server -- 解决存储过程传入参数作为s
     



              关于JS定时器的整理
     
JS中使用Promise.all控制所有的异步请求都完
     
js中字符串的方法
     
import-local执行流程与node模块路径解析流程
     
检测数据类型的四种方法
     
js中数组的方法,32种方法
     
前端操作方法
     
数据类型
     
window.localStorage.setItem 和 localStorage.setIte
     
如何完美解决前端数字计算精度丢失与数






 




相关教程





python基础教程
软件开发
PHP教程
sql教程
vb.net教程
sql语句大全
asp.net教程
dreamweaver教程
javascript教程
flash教程
vb教程
计算机二级vfp
access教程
html5教程
C#教程
web前端 
python入门教程 










  
   
   
	



关于我们--广告服务--免责声明--本站帮助-友情链接--版权声明--联系我们

  
  
黑ICP备07002182号

首页 > temp > 简明python教程 >