ASP.Net Core-依赖注入IoC

时间  2019-12-08
标签 asp.net asp core 依赖 注入 ioc 栏目 ASP 繁體版
原文   原文链接

1、Ioc数据库

IoC全称Inverse of Control，控制反转。设计模式

类库和框架的不一样之处在于，类库是实现某种单一功能的API，框架是针对一个任务把这些单一功能串联起来造成一个完整的流程，这个流程在一个引擎驱动下被执行。缓存

IoC的整体设计是要把在应用程序的流程控制转移到框架中，实现对流程的复用，这 符合软件设计的基本原则-重用性。app

IoC不是一种设计模式，它是一种设计原则。而且不少设计模式都遵循了这种原则。好比：模板模式、工厂模式、抽象工厂模式。框架

 

2、DIide

DI全称Dependency Indection，依赖注入。它是IoC模式的一种。函数

咱们写的对象要完成某个功能可能要依赖于另一个对象，好比咱们要添加一我的员，每每会在逻辑层调用数据操做层来实现添加到数据库的操做。DI会在程序初始化的时候，把数据操做层的接口和实现接口的类关联起来，那么在逻辑层咱们只要声明要调用的具体数据操做层的接口，调用接口的方法，这样就实现了逻辑层和数据操做层的解耦。ui

所谓依赖注入能够理解为一种针对依赖的字段或者属性的一种自动初始化方式。this

 

举例说明，当咱们经过VS2015建立了一个.Net Core项目，而且带有我的身份验证Identity，具体如何建立在此再也不细说。spa

咱们看到在Startup中，有个方法

       

// This method gets called by the runtime. Use this method to add services to the container.

        public void ConfigureServices(IServiceCollection services)

        {

            // Add framework services.

            services.AddDbContext<ApplicationDbContext>(options =>

                options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

            services.AddIdentity<ApplicationUser, IdentityRole>()

                .AddEntityFrameworkStores<ApplicationDbContext>()

                .AddDefaultTokenProviders();

            services.AddMvc();

            // Add application services.

            services.AddTransient<IEmailSender, AuthMessageSender>();

            services.AddTransient<ISmsSender, AuthMessageSender>();

        }
View Code

 

Controller中：

[Authorize]
public class AccountController : Controller
{
     private readonly UserManager<ApplicationUser> _userManager;
     private readonly SignInManager<ApplicationUser> _signInManager;
     private readonly IEmailSender _emailSender;
     private readonly ISmsSender _smsSender;
     private readonly ILogger _logger;

     public AccountController(
         UserManager<ApplicationUser> userManager,
         SignInManager<ApplicationUser> signInManager,
         IEmailSender emailSender,
         ISmsSender smsSender,
         ILoggerFactory loggerFactory)
     {
         _userManager = userManager;
         _signInManager = signInManager;
         _emailSender = emailSender;
         _smsSender = smsSender;
         _logger = loggerFactory.CreateLogger<AccountController>();
     }
}
View Code

 

咱们看到，咱们并无实例化AccountController中的字段，只是在构造函数把相关联的字段当作参数传进来，系统自动就会实例化。这个实例化的过程就是DI帮助咱们完成的。

DI注入方式有3种：构造器注入、属性注入、方法注入。

DI容器就是一个服务的提供者。当须要某个服务的时候，只要从DI容器中获取就能够。

 

3、.NET 中的DI

ServiceProvider对象是DI容器的核心对象，他在Microsoft.Extensions.DependencyInjection.dll程序集的同名命名空间下。是一个程序集内部类。这个类的主要任务就是根据服务类型提供服务对象。

与这个类相关联的类有：ServiceCallSite、Service、ServiceEntry和ServiceTable。他们都有相应的接口。

 

1.ServiceCallSite

服务的最终提供者就是这个对象，这个对象继承自接口IServiceCallSite。

namespace Microsoft.Extensions.DependencyInjection.ServiceLookup
{
    using Microsoft.Extensions.DependencyInjection;
    using System;
    using System.Linq.Expressions;

    internal interface IServiceCallSite
    {
        Expression Build(Expression provider);
        object Invoke(ServiceProvider provider);
    }
}
View Code

当须要一个服务实例的时候，会去对应的ServiceCallSite中调用Invoke方法，返回须要的实例。同时，还会调用Invoke方法返回表达式，并会缓存起来，等到下次获取相同实例的时候直接获取。

2.Service

当咱们获取服务对象实例的时候是根据ServiceCollection提供的。ServiceCollection和咱们链接很是紧密，就是咱们在Startup中添加的服务于实现的关联。

ServiceCollection中保存的就是ServiceDescriptor，每一个ServiceDescriptor都会被转化成Service，继承自接口IService。

namespace Microsoft.Extensions.DependencyInjection.ServiceLookup
{
    using Microsoft.Extensions.DependencyInjection;
    using System;
    using System.Collections.Generic;

    internal interface IService
    {
        IServiceCallSite CreateCallSite(ServiceProvider provider, ISet<Type> callSiteChain);

        ServiceLifetime Lifetime { get; }

        IService Next { get; set; }
    }
}
View Code

咱们看到，这个接口中有CreateCallSite获得一个ServiceCallSite实例。每一个Service都是以链表的形式存在，Next表示链表的下一个节点，这个链表就是具备相同的服务类型组成。

3.ServiceEntry

表示上面说的链表。

namespace Microsoft.Extensions.DependencyInjection.ServiceLookup
{
    using System;
    using System.Runtime.CompilerServices;

    internal class ServiceEntry
    {
        private object _sync = new object();

        public ServiceEntry(IService service)
        {
            this.First = service;
            this.Last = service;
        }

        public void Add(IService service)
        {
            object obj2 = this._sync;
            lock (obj2)
            {
                this.Last.Next = service;
                this.Last = service;
            }
        }

        public IService First { get; private set; }

        public IService Last { get; private set; }
    }
}
View Code

4.ServiceTable

多个ServiceEntry组成一个ServiceTable。

namespace Microsoft.Extensions.DependencyInjection.ServiceLookup
{
    using Microsoft.Extensions.DependencyInjection;
    using System;
    using System.Collections.Concurrent;
    using System.Collections.Generic;
    using System.Reflection;
    using System.Runtime.InteropServices;

    internal class ServiceTable
    {
        private readonly Dictionary<Type, List<IGenericService>> _genericServices = new Dictionary<Type, List<IGenericService>>();
        private readonly ConcurrentDictionary<Type, Func<ServiceProvider, object>> _realizedServices = new ConcurrentDictionary<Type, Func<ServiceProvider, object>>();
        private readonly Dictionary<Type, ServiceEntry> _services = new Dictionary<Type, ServiceEntry>();
        private readonly object _sync = new object();

        public ServiceTable(IEnumerable<ServiceDescriptor> descriptors)
        {
            foreach (ServiceDescriptor descriptor in descriptors)
            {
                if (IntrospectionExtensions.GetTypeInfo(descriptor.ServiceType).IsGenericTypeDefinition)
                {
                    TypeInfo info = (descriptor.ImplementationType == null) ? null : IntrospectionExtensions.GetTypeInfo(descriptor.ImplementationType);
                    if ((info == null) || !info.IsGenericTypeDefinition)
                    {
                        throw new ArgumentException(Resources.FormatOpenGenericServiceRequiresOpenGenericImplementation(descriptor.ServiceType), "descriptors");
                    }
                    if (info.IsAbstract || info.IsInterface)
                    {
                        throw new ArgumentException(Resources.FormatTypeCannotBeActivated(descriptor.ImplementationType, descriptor.ServiceType));
                    }
                    this.Add(descriptor.ServiceType, new GenericService(descriptor));
                }
                else if (descriptor.ImplementationInstance != null)
                {
                    this.Add(descriptor.ServiceType, new InstanceService(descriptor));
                }
                else if (descriptor.ImplementationFactory != null)
                {
                    this.Add(descriptor.ServiceType, new FactoryService(descriptor));
                }
                else
                {
                    TypeInfo typeInfo = IntrospectionExtensions.GetTypeInfo(descriptor.ImplementationType);
                    if ((typeInfo.IsGenericTypeDefinition || typeInfo.IsAbstract) || typeInfo.IsInterface)
                    {
                        throw new ArgumentException(Resources.FormatTypeCannotBeActivated(descriptor.ImplementationType, descriptor.ServiceType));
                    }
                    this.Add(descriptor.ServiceType, new Service(descriptor));
                }
            }
        }

        public void Add(Type serviceType, IGenericService genericService)
        {
            object obj2 = this._sync;
            lock (obj2)
            {
                List<IGenericService> list;
                if (!this._genericServices.TryGetValue(serviceType, ref list))
                {
                    list = new List<IGenericService>();
                    this._genericServices.set_Item(serviceType, list);
                }
                list.Add(genericService);
            }
        }

        public void Add(Type serviceType, IService service)
        {
            object obj2 = this._sync;
            lock (obj2)
            {
                ServiceEntry entry;
                if (this._services.TryGetValue(serviceType, ref entry))
                {
                    entry.Add(service);
                }
                else
                {
                    this._services.set_Item(serviceType, new ServiceEntry(service));
                }
            }
        }

        public bool TryGetEntry(Type serviceType, out ServiceEntry entry)
        {
            object obj2 = this._sync;
            lock (obj2)
            {
                if (this._services.TryGetValue(serviceType, ref entry))
                {
                    return true;
                }
                if (IntrospectionExtensions.GetTypeInfo(serviceType).IsGenericType)
                {
                    List<IGenericService> list;
                    Type genericTypeDefinition = serviceType.GetGenericTypeDefinition();
                    if (this._genericServices.TryGetValue(genericTypeDefinition, ref list))
                    {
                        using (List<IGenericService>.Enumerator enumerator = list.GetEnumerator())
                        {
                            while (enumerator.MoveNext())
                            {
                                IService service = enumerator.get_Current().GetService(serviceType);
                                if (service != null)
                                {
                                    this.Add(serviceType, service);
                                }
                            }
                        }
                        return this._services.TryGetValue(serviceType, ref entry);
                    }
                }
            }
            return false;
        }

        public ConcurrentDictionary<Type, Func<ServiceProvider, object>> RealizedServices
        {
            get
            {
                return this._realizedServices;
            }
        }
    }
}
View Code

主要的方法就是在ServiceTable构造函数中，根据传过来的ServiceDescriptor列表，其实就是咱们在Startup中注册的服务与具体实现转换过来的。

在这个构造函数中会先根据ServiceType转换成ServiceEntry列表，再添加到Dictionary<Type, ServiceEntry> _services 中，也就是最终获得的是_services类型。

5.ServiceProvider

   1：   internal class ServiceProvider : IServiceProvider, IDisposable

   2: {

   3:     public ServiceProvider Root { get; private set; }

   4:     public ServiceTable ServiceTable { get; private set; }

   5:     public ConcurrentDictionary<Type, Func<ServiceProvider, object>> RealizedServices { get; private set; } = new ConcurrentDictionary<Type, Func<ServiceProvider, object>>();

   6:     public IList<IDisposable> TransientDisposableServices { get; private set; } = new List<IDisposable>();

   7:     public ConcurrentDictionary<IService, object> ResolvedServices { get; private set; } = new ConcurrentDictionary<IService, object>();

   8:     

   9:     public ServiceProvider(IServiceCollection services)

  10:     {

  11:         this.Root         = this;

  12:         this.ServiceTable     = new ServiceTable(services);

  13:     }

  14:  

  15:     public object GetService(Type serviceType)

  16:     {

  17:         Func<ServiceProvider, object> serviceAccessor;

  18:         if (this.RealizedServices.TryGetValue(serviceType, out serviceAccessor))

  19:         {

  20:             return serviceAccessor(this);

  21:         }

  22:  

  23:         IServiceCallSite serviceCallSite = this.GetServiceCallSite(serviceType, new HashSet<Type>());

  24:         if (null != serviceCallSite)

  25:         {

  26:             var providerExpression = Expression.Parameter(typeof(ServiceProvider), "provider");

  27:             this.RealizedServices[serviceType] = Expression.Lambda<Func<ServiceProvider, object>>(serviceCallSite.Build(providerExpression), providerExpression).Compile();

  28:             return serviceCallSite.Invoke(this);

  29:         }

  30:  

  31:         this.RealizedServices[serviceType] = _ => null;

  32:         return null;

  33:     }

  34:  

  35:     public IServiceCallSite GetServiceCallSite(Type serviceType, ISet<Type> callSiteChain)

  36:     {

  37:             try

  38:             {

  39:                 if (callSiteChain.Contains(serviceType))

  40:                 {

  41:                     throw new InvalidOperationException(string.Format("A circular dependency was detected for the service of type '{0}'", serviceType.FullName);

  42:                 }

  43:                 callSiteChain.Add(serviceType);

  44:  

  45:                 ServiceEntry serviceEntry;

  46:                 if (this.ServiceTable.ServieEntries.TryGetValue(serviceType, 

  47:                     out serviceEntry))

  48:                 {

  49:                     return serviceEntry.Last.CreateCallSite(this, callSiteChain);

  50:                 }

  51:  

  52:                 //省略其余代码

  53:  

  54:                 return null;

  55:             }

  56:             finally

  57:             {

  58:                 callSiteChain.Remove(serviceType);

  59:             }

  60:     }    

  61:  

  62:     public void Dispose()

  63:     {

  64:         Array.ForEach(this.TransientDisposableServices.ToArray(), _ => _.Dispose());

  65:         Array.ForEach(this.ResolvedServices.Values.ToArray(), _ => (_ as IDisposable)?.Dispose());

  66:         this.TransientDisposableServices.Clear();

  67:         this.ResolvedServices.Clear();

  68:     }

  69:     //其余成员

  70: }
View Code


以上借助他人的代码片断，ServiceProvider中主要有几个属性，root指向本身；RealizedServices 就是在咱们讲解ServiceCallSite时说道，最后获得的Service会被生成委托以便下次调用，这个委托就存在这个属性中。

这个类最主要的方法就是GetService，主要逻辑就是从RealizedServices 获取当前服务的实例，若是有，直接返回，若是没有，会从ServiceTable中找到对应的ServiceEntry，若是没有返回null，若是有，调用ServiceEntry所在列表最后一个Service的CreateServiceCallSite方法建立一个ServiceCallSite对象（这一点说明了若是针对同一个服务类型注册了多个ServiceDescriptor，在提供单个服务的时候老是使用最后一个 ServiceDescriptor）。

 

综上，.net core中的DI容器的主要对象就是ServiceProvider、ServiceCallSite、Service、ServiceEntry和ServiceTable。主要的流程控制都放在ServiceProvider类中，这个类有一个ServiceTable（就是ServiceType和ServiceEntry的对应列表）。ServiceEntry就是一个链表，连接了当前ServiceType的全部的实例（不过获得的实例老是以最后一个为准），实例的类型都是Service类型。Service主要就是获取ServiceCallSite对象，这个对象就是封装了全部的获取具体服务实例的逻辑，主要经过Invoke获得实例，再调用Build生成表达式委托，存在ServiceProvider中。

ServiceProvider主要有一个方法GetService获取服务实例。主要逻辑就是从RealizedServices 获取当前服务的实例，若是有，直接返回，若是没有，会从ServiceTable中找到对应的ServiceEntry，若是没有返回null，若是有，调用ServiceEntry所在列表最后一个Service的CreateServiceCallSite方法建立一个ServiceCallSite对象（这一点说明了若是针对同一个服务类型注册了多个ServiceDescriptor，在提供单个服务的时候老是使用最后一个 ServiceDescriptor）。

 

事后思考：

1. ServiceCallSite：获取咱们要的最终的服务实例并缓存起来以备下次调用。

2.Service:获取ServiceCallSite，由咱们注册的服务转换而来，链表形式存在，整个链表表示相同实例类型的实例。

3.ServiceEntry：对链表Service的封装，有First、Last表示链表的第一个和最后一个，还有个Add方法。

4.ServiceTable：主要对象就是Dictionary<Type,ServiceEntry> _service,表示服务类型和服务实例链表的对应关系。

5.ServiceProvider:整个DI功能的控制者，主要方法就是GetService，根据类型获取实例。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程