为.net core网站添加通用的操作引导指南(IntroJs)

接上级领导命令, 需要为开发的网站添加一个操作引导功能,让用户进入网站后可以大概了解如何操作.

实现该功能使用intro.js插件及asp.net core中组件(由于.net core中 @html.renderaction已经移除)来完成.

点击下载introjs

一. 首先是创建components

1. 在views/shared/components(没有请新建)目录下创建”IntroJs”目录

2. 创建ViewModel实体类

    public class IntroJsViewModel
    {
        /// <summary>
        /// 区域名
        /// </summary>
        public string Area { get; set; }

        /// <summary>
        /// 控制器名
        /// </summary>
        public string Controller { get; set; }

        /// <summary>
        /// 页面名
        /// </summary>
        public string Action { get; set; }

        /// <summary>
        /// 步骤列表
        /// </summary>
        public IntroStep[] Steps { get; set; }
    }

    public class IntroStep
    {
        /// <summary>
        /// 唯一选择器
        /// </summary>
        public string Element { get; set; }

        /// <summary>
        /// 步骤序号 1 ,2 ,3 ,4
        /// </summary>
        public int Step { get; set; }

        /// <summary>
        /// 提示文本, 可以为html
        /// </summary>
        public string Intro { get; set; }

        /// <summary>
        /// 位置, left right top  可为空
        /// </summary>
        public string Position { get; set; }
    }

3. 创建ViewComponent类

    public class IntroJsViewComponent: ViewComponent
    {
        public IntroJsViewComponent()
        {

        }

        public IViewComponentResult Invoke()
        {
            var routes = RouteData.Routers[0];
            var area = RouteData.Values["Area"] as string;
            area = string.IsNullOrWhiteSpace(area) ? "" : area.ToLower();
            var controller = RouteData.Values["Controller"].ToString().ToLower();
            var action = RouteData.Values["Action"].ToString().ToLower();
            StringBuilder sb = new StringBuilder();
            string line = string.Empty;
            string filepath = System.IO.Directory.GetCurrentDirectory() + "/IntroSettings.json";
            if (File.Exists(filepath))
            {
                using (StreamReader sr = new StreamReader(filepath))
                {
                    while ((line = sr.ReadLine()) != null)
                    {
                        sb.Append(line);
                    }
                }
                var stepList = JsonConvert.DeserializeObject<List<IntroJsViewModel>>(sb.ToString());
                var step = stepList.FirstOrDefault(x =>
                    x.Area.ToLower() == area && x.Controller.ToLower() == controller && x.Action.ToLower() == action);
                step = step == null ? new IntroJsViewModel{ Steps = new IntroStep[0]}: step;
                return View(step);
            }
            return View(new IntroJsViewModel { Steps = new IntroStep[0] });
        }
    }

4. 添加默认的Default.cshtml视图文件

文件代码如下:

@using WebProject.Views.Shared.Components.IntroJs
@model IntroJsViewModel
@{

}
<script type="text/javascript" src="~/Scripts/introjs/intro.min.js"></script>
<script>
    var showIntro = true;
    var steps = [];
    $(function () {

        @{
            foreach (var item in Model.Steps)
            {
                <text>steps.push({ element: '@item.Element', intro: '@item.Intro', position: '@item.Position' });</text>
            }
        }
        if (showIntro) {
            introJs().setOptions({
                prevLabel: "上一步",
                nextLabel: "下一步",
                skipLabel: "跳过",
                doneLabel: "完成",
                showProgress: true, //显示进度条
                steps:steps
            }).start();
        }
    });

</script>

二. 在需要添加引导的页面引用该组件

一般在母版页底部进行引用.

@await Component.InvokeAsync("IntroJs")

三. 添加配置文件

在项目根目录添加”IntroSettings.json”配置文件

area和controller及action用来确定页面(可以多个)

steps节点下的element为该页面下的dom选择器,如ID等, 请务必保证唯一,否则将影响效果

step为该提示的步骤, 从数字1开始

intro为引导的文字说明

position为文字说明在该dom元素的哪个方向. left,right,top, bottom

[
  {
    "Area": "FormStat",
    "Controller": "WKEntryYear",
    "Action": "Index",
    "Steps": [
      {
        "Element": "#divContent",
        "Step": 1,
        "Intro": "这里是头部......",
        "Position": ""
      },
      {
        "Element": "#btnSearch",
        "Step": 2,
        "Intro": "搜索内容 ",
        "Position": ""
      }
    ]
  }
]

 

五. 效果图

[转]IOC(依赖注入)–入门篇

之前就听同事说过依赖注入(dependency injection)、控制反转(Inversion of Control)。起初听的是一头雾水,试着在项目中运用了几次,总算明白了一些,抛砖引玉,与大家分享一下拙见。

其实依赖注入和控制反转指的都是同一个事情。什么是依赖注入了???

【个人理解】

以最熟悉的三层架构的项目来说,BLL层依赖DAL层,UI层依赖于BLL层,层层之间紧密联系。代码里到处都是new 对象。认识IOC后,发现IOC最大的好处就是解耦了对这种层级之间的依赖关系进。程序本身不在负责对象的创建和维护,而交给外部容器(IOC容器)来负责。外部容器在运行时动态地将依赖的对象注入到组件之中。

简单的来说就是在类型A中需要使用类型B的实例,而B实例的创建并不由A来负责,而是通过外部容器来创建。相比以往实例化对象的写法,确实很爽。

以往实例化都是这样的:

public class A
{
    public A(B b)
    {
        this.B = b;
    }
 
    public B B { get; set; }
 
    public void Test(B b)
    {
        Console.WriteLine(b.ToString());
    }
}

A 类受B类的影响很大。A类的构造函数中,实例化B,且在A类的Test的方法中,需要判断B类是不是被实例化。A即创建B又需要维护B。用了IOC,解耦了这种依赖关系。接下来看看我在项目中是怎么简单应用的。

 

【项目简单试用】

一开始用的IOC容器是Unity,四个字,短小精干(用了有段日子。还有好多功能还需不断去探索) 。网上还有其它的IOC容器,没有去了解过(个人认为,能把一个工具用会,用熟,用精,才是王道。)

我把项目中的一段代码摘出来,项目需求大致上是项目有个数据统计,它下面有三种不同的统计类型,需要与数据库交互,然后展示到页面。

首先需要Unity的类库,利用VS2012的库程序包管理工具去下载Unity的类库。

项目的结构是这样,标准的是三层架构,BLL和DAL都有接口层IBLL,IDAL。

首先我们按照不用IOC的方式来实现这个小需求。

IDAL,IBLL 创建接口?IAnalyse 接口里有个方法

public interface IAnalyse
    {
        /// <summary>
        /// 显示结果
        /// </summary>
        void ShowResult();
    }

DAL 层引用IDAL,创建类?Analyse.cs

public class Analyse:IDAL.IAnalyse
    {
        public void ShowResult()
        {
            Console.WriteLine("分析底层数据库交互");
        }
    }

BLL层引用IDAL,DAL,IBLL 创建?类?Analyse.cs

        /// <summary>
        /// 显示结果
        /// </summary>
        public void ShowResult()
        {
            ////以前思路 需要引用IBLL,IDAL,DAL
            IDAL.IAnalyse dal = new DAL.Analyse();
            dal.ShowResult();
        }

UI层用控制台应用程序来代替。需引用IBLL,BLL

class Program
    {
        static void Main(string[] args)
        {
            OldMethod();
            Console.ReadKey();
        }

        /// <summary>
        /// 在使用IOC前的写法。需要引入IBLL,BLL
        /// </summary>
        static void OldMethod()
        {
            IBLL.IAnalyse bll = new BLL.Analyse();
            bll.ShowResult(); 
        }
    }

按照以前的方法,每个层我们都在不断的new 对象。写到这里发现这些都是很中规中矩的写法,以前老师教的也是这样,可能你会觉得没啥不好的。我就假如:BLL.Analyse 的构造函数需要参数,参数为Class B ,去掉无参的构造函数,你是不是所有new 对象的地方都要更改。小项目也许还没有问题,如果是上百万的大项目咋办。这就是所谓的层与层之间的耦合度高。(个人拙见,多多指教)

接下来我们用 IOC 来解耦。在Program.cs 增加?IOCMethod1 方法

static void Main(string[] args)
        {
            //OldMethod();
            IOCMethod1();
            Console.ReadKey();
        }

static void IOCMethod1()
        {
            IUnityContainer container=new UnityContainer();
            ////在容器中注册一种类型,它是一个类型的映射,接口类型是IAnalyse,希望返回的类型是Analyse
            container.RegisterType<IBLL.IAnalyse, BLL.Analyse>();
            ////第二种写法
            //container.RegisterType(typeof (IBLL.IAnalyse), typeof (BLL.Analyse));
            IBLL.IAnalyse bll = container.Resolve<IBLL.IAnalyse>();
            bll.ShowResult();
        }

使用unity就三步:

第一,new IOC 容器

第二,调用RegisterType 注册类型。这里有多种注册形式。可以注册单例的、构造函数有参数的。

第三,调用Resolve 创建对象

(认识IOC 简单吧 O(∩_∩)O)

到这,你会发现,UI层 仍然引用了IBLL,BLL,RegisterType方法需要这两个类库。既然是解耦,就得解耦彻底些。有什么方法???

我在Core层?DependencyRegister.cs. 建立一个静态方法,在程序运行开始的时候,注册所有的类型。UI 层移除BLL ,引用Core

namespace Core
{
    /// <summary>
    /// 类型注册
    /// </summary>
    public class DependencyRegister
    {


        public static IUnityContainer DependencyRegisterContainer()
        {
            IUnityContainer container = new UnityContainer();
            container.RegisterType<IBLL.IAnalyse, BLL.Analyse>()
                     .RegisterType<IDAL.IAnalyse, DAL.Analyse>();
            return container;
        }
    }
}


////UI层 先移除BLL,引用Core
static void Main(string[] args)
        {
            
            IOCMethod2();
            Console.ReadKey();
        }

static void IOCMethod2()
        {

  IUnityContainer container = DependencyRegister.DependencyRegisterContainer();
IBLL.IAnalyse bll = container.Resolve<IBLL.IAnalyse>(); 
bll.ShowResult(); 
    }

这样达到了解耦的目标,如何需要更改类的构造函数,只需更改Core?DependencyRegister.cs 就可以了。

 

【其它解耦方式】

建立core是用了自己得方法来实现解耦的,其实unity还有更觉得,通过配置文件 app.config 来实现。用的是?Microsoft.Practices.Unity.Configuration.dll

    <!-- 程序集-->
    <assembly name="IBLL"/>
    <assembly name="IDAL"/>
    <!--要返回的类型-->
    <alias alias="BLLAnalyse1" type="BLL.Analyse, BLL" />
    <container name="ContainerAnalyse">
      <register type="IBLL.IAnalyse" name="BLLAnalyse1" mapTo="BLLAnalyse1" />
    </container>
private static void IOCMethod3()
        {
            ////通过配置文件注册所有类型
            IUnityContainer container=new UnityContainer();
            UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
            section.Configure(container, "ContainerAnalyse");
            IBLL.IAnalyse bll = container.Resolve<IBLL.IAnalyse>("BLLAnalyse1");
            bll.ShowResult();
        }

【投机取巧】

无论是使用全局方法,或者 配置文件,都是注册类的形式不同。每种方法都需要调用Resolve 来创建对象。有没有连改方法都不用调用的形式。

不用多说,直接上代码:

namespace BLL
{
    public class Analyse:IBLL.IAnalyse
    {
        ////使用依赖注入
        [Dependency]
        public IDAL.IAnalyse dal { get; set; }
        /// <summary>
        /// 显示结果
        /// </summary>
        public void ShowResult()
        {
            ////以前思路 需要引用IBLL,IDAL,DAL
            //IDAL.IAnalyse dal = new DAL.Analyse();
            
            
            dal.ShowResult();
        }
    }
}

使用[Dependency]属性。说实话,它的用法还有些没有弄明白。希望明白这个得多指教指教。

献丑了,有什么不对的地方希望大家多多指教。Unity 功能很多,这篇只不过是凤毛麟角,还有什么构造注入,属性注入、单例的应用。这些,将在下篇继续分享。希望大家继续关注,多多指教。

【源码下载】

 

原文:http://www.cnblogs.com/ttrjba/p/3511935.html

[转]ASP.Net MVC Core-依赖注入IoC

一、Ioc

IoC全称Inverse of Control,控制反转。

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

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

IoC不是一种设计模式,它是一种设计原则。并且很多设计模式都遵循了这种原则。比如:模板模式、工厂模式、抽象工厂模式。

 

二、DI

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

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

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

 

举例说明,当我们通过VS2015创建了一个.Net Core项目,并且带有个人身份验证Identity,具体如何创建在此不再细说。

我们看到在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>();

        }

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>();
     }
}

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

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

DI容器就是一个服务的提供者。当需要某个服务的时候,只要从DI容器中获取就可以。

三、.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);
    }
}

当需要一个服务实例的时候,会去对应的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; }
    }
}

我们看到,这个接口中有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; }
    }
}

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;
            }
        }
    }
}

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

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

5.ServiceProvider

      internal class ServiceProvider : IServiceProvider, IDisposable
    {
        public ServiceProvider Root { get; private set; }
        public ServiceTable ServiceTable { get; private set; }
        public ConcurrentDictionary<Type, Func<ServiceProvider, object>> RealizedServices { get; private set; } = new ConcurrentDictionary<Type, Func<ServiceProvider, object>>();
        public IList<IDisposable> TransientDisposableServices { get; private set; } = new List<IDisposable>();
        public ConcurrentDictionary<IService, object> ResolvedServices { get; private set; } = new ConcurrentDictionary<IService, object>();
        
        public ServiceProvider(IServiceCollection services)
        {
           this.Root         = this;
           this.ServiceTable     = new ServiceTable(services);
        }
     
        public object GetService(Type serviceType)
        {
            Func<ServiceProvider, object> serviceAccessor;
            if (this.RealizedServices.TryGetValue(serviceType, out serviceAccessor))
            {
               return serviceAccessor(this);
            }
    
            IServiceCallSite serviceCallSite = this.GetServiceCallSite(serviceType, new HashSet<Type>());
            if (null != serviceCallSite)
            {
                var providerExpression = Expression.Parameter(typeof(ServiceProvider), "provider");
                this.RealizedServices[serviceType] = Expression.Lambda<Func<ServiceProvider, object>>(serviceCallSite.Build(providerExpression), providerExpression).Compile();
                return serviceCallSite.Invoke(this);
            }
    
            this.RealizedServices[serviceType] = _ => null;
            return null;
        }
     
        public IServiceCallSite GetServiceCallSite(Type serviceType, ISet<Type> callSiteChain)
        {
                try
                {
                    if (callSiteChain.Contains(serviceType))
                    {
                        throw new InvalidOperationException(string.Format("A circular dependency was detected for the service of type '{0}'", serviceType.FullName);
                    }
                    callSiteChain.Add(serviceType);
     
                   ServiceEntry serviceEntry;
                    if (this.ServiceTable.ServieEntries.TryGetValue(serviceType, 
                        out serviceEntry))
                    {
                        return serviceEntry.Last.CreateCallSite(this, callSiteChain);
                    }
     
                    //省略其他代码
     
                    return null;
                }
                finally
                {
                    callSiteChain.Remove(serviceType);
                }
        }    
     
        public void Dispose()
        {
            Array.ForEach(this.TransientDisposableServices.ToArray(), _ => _.Dispose());
            Array.ForEach(this.ResolvedServices.Values.ToArray(), _ => (_ as IDisposable)?.Dispose());
            this.TransientDisposableServices.Clear();
            this.ResolvedServices.Clear();
        }
        //其他成员
    }

以上借助他人的代码片段,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,根据类型获取实例。

 

原文地址:http://www.cnblogs.com/zh1990/p/5674128.html