乘胜左近的类型尤其多,多数等级次序都引进了依赖注入框架,个中最风靡的有Castle
温莎, Autofac和Unity Container。
微软在风靡版的Asp.Net
Core中自带了依附注入的意义,有意思味能够翻看那里。
关于怎么着是借助注入容器网络一度有数不清的篇章介绍,那里自身将器重讲述如何兑现三个本人的容器,能够帮忙您知道正视注入的法则。

乘机大规模的门类更加多,多数品类都引进了借助注入框架,个中最流行的有Castle
温莎, Autofac和Unity Container。
微软在新型版的Asp.Net
Core中自带了正视注入的机能,风乐趣能够查看那里。
关于什么是依赖注入容器网络早已有为数不少的稿子介绍,那里自身将重大讲述怎么样完结一个友好的容器,能够扶助你精通注重注入的法则。

在眼下的章节(Middleware章节)中,大家提到了依据注入功效(Dependency
Injection),ASP.NET
5正式将借助注入实行了全职能的兑现,以便开采人士能够开荒更具弹性的组件程序,MVC⑥也接纳了依附注入的成效重新对Controller和View的服务注入成效举行了双重设计;未来的信赖性注入作用还或许提供越来越多的API,全部要是还尚无起来接触依赖注入的话,就得好好学一下了。

在前边的章节(Middleware章节)中,我们提到了重视注入功能(Dependency
Injection),ASP.NET
伍正式将依据注入进行了全职能的兑现,以便开拓人士能够开拓更具弹性的组件程序,MVC陆也应用了重视注入的效能重新对Controller和View的劳务注入成效举行了重新规划;现在的依赖注入功用还也许提供越多的API,全部假如还尚无起来接触依赖注入的话,就得好好学一下了。

容器的构想

在编辑容器以前,应该先想好那一个容器怎么着采用。
容器允许登记服务和贯彻项目,允许从服务类型得出服务的实例,它的利用代码应该像

var container = new Container();

container.Register<MyLogger, ILogger>();

var logger = container.Resolve<ILogger>();

容器的构想

在编写容器在此之前,应该先想好那一个容器怎么样行使。
容器允许注册服务和兑现项目,允许从服务类型得出服务的实例,它的选择代码应该像

var container = new Container();

container.Register<MyLogger, ILogger>();

var logger = container.Resolve<ILogger>();

在前边版本的注重性注入效能里,注重注入的进口有MVC中的IControllerFactory和Web
API中的IHttpControllerActivator中,在新版ASP.NET5中,依赖注入产生了最尾部的基础支撑,MVC、Routing、SignalLacrosse、Entity
Framrwork等都依据于依据注入的IServiceProvider接口,针对该接口微软交付了暗中认可的得以达成ServiceProvider,以及Ninject和AutoFac版本的卷入,当然你也足以运用别的第叁方的信赖性注入容器,如Castle
温莎等;1旦采取了第二方容器,全部的依据解析都会被路由到该第一方容器上。

在头里版本的依据注入功效里,重视注入的输入有MVC中的IControllerFactory和Web
API中的IHttpControllerActivator中,在新版ASP.NET5中,依赖注入变成了最尾部的底蕴支撑,MVC、Routing、Signal卡宴、Entity
Framrwork等都依据于依据注入的IServiceProvider接口,针对该接口微软交付了暗中认可的落到实处ServiceProvider,以及Ninject和AutoFac版本的包装,当然你也得以使用其余第叁方的重视性注入容器,如Castle
温泽等;一旦选用了第一方容器,全数的依附解析都会被路由到该第一方容器上。

最基础的容器

在下边包车型地铁构想中,Container类有八个函数,三个是Register,一个是Resolve
容器要求在Register时关联ILogger接口到MyLogger实现,并且供给在Resolve时知道应该为ILogger生成MyLogger的实例。
以下是促成那五个函数最基础的代码

public class Container
{
    // service => implementation
    private IDictionary<Type, Type> TypeMapping { get; set; }

    public Container()
    {
        TypeMapping = new Dictionary<Type, Type>();
    }

    public void Register<TImplementation, TService>()
        where TImplementation : TService
    {
        TypeMapping[typeof(TService)] = typeof(TImplementation);
    }

    public TService Resolve<TService>()
    {
        var implementationType = TypeMapping[typeof(TService)];
        return (TService)Activator.CreateInstance(implementationType);
    }
}

Container在内部创造了二个服务类型(接口类型)到实现项目标目录,Resolve时使用索引找达到成项目并创办实例。
这一个达成相当粗略,但是有不少主题素材,例如

  • 2个服务类型无法对应多少个得以完结项目
  • 尚无对实例进行生命周期管理
  • 从没实现构造函数注入

最基础的容器

在上头的构想中,Container类有四个函数,三个是Register,一个是Resolve
容器需求在Register金沙注册送58,时关联ILogger接口到MyLogger得以达成,并且需求在Resolve时知道应该为ILogger生成MyLogger的实例。
以下是贯彻那七个函数最基础的代码

public class Container
{
    // service => implementation
    private IDictionary<Type, Type> TypeMapping { get; set; }

    public Container()
    {
        TypeMapping = new Dictionary<Type, Type>();
    }

    public void Register<TImplementation, TService>()
        where TImplementation : TService
    {
        TypeMapping[typeof(TService)] = typeof(TImplementation);
    }

    public TService Resolve<TService>()
    {
        var implementationType = TypeMapping[typeof(TService)];
        return (TService)Activator.CreateInstance(implementationType);
    }
}

Container在内部创立了三个服务类型(接口类型)到贯彻项目的目录,Resolve时行使索引找到达成项目并创办实例。
那个完结很轻易,不过有成都百货上千标题,比如

  • 三个服务类型不能够对应四个落到实处项目
  • 从不对实例进行生命周期管理
  • 【金沙注册送58】信赖注入,怎么样编写四个简练的信赖性注入容器。从未有过兑现构造函数注入

针对通用的重视类型的剖析与成立,微软默料定义了肆种档期的顺序的生命周期,分别如下:

针对通用的重视类型的解析与创设,微软默料定义了4种类型的生命周期,分别如下:

查对容器的构想 – 类型索引类型

要让贰个服务类型对应四个落实项目,能够把TypeMapping改为

IDictionary<Type, IList<Type>> TypeMapping { get; set; }

假设其余提供一个保存实例的变量,也能兑现生命周期管理,但显得某些复杂了。
那里能够转移一下思路,把{服务类型=>落成项目}改为{服务类型=>工厂函数},让生命周期的管理在工厂函数中落到实处。

IDictionary<Type, IList<Func<object>>> Factories { get; set; }

突发性我们会想让用户在布署文件中切换完成项目,那时倘诺把键类型改成服务类型+字符串,落成起来会简单大多。
Resolve能够这么用:
Resolve<Service>(serviceKey: Configuration["ImplementationName"])

IDictionary<Tuple<Type, string>, IList<Func<object>>> Factories { get; set; }

校正容器的构想 – 类型索引类型

要让1个服务类型对应多少个得以达成项目,能够把TypeMapping改为

IDictionary<Type, IList<Type>> TypeMapping { get; set; }

要是此外提供四个保存实例的变量,也能兑现生命周期管理,但显得有点复杂了。
此间可以转移一下思路,把{服务类型=>实现项目}改为{服务类型=>工厂函数},让生命周期的田间管理在工厂函数中落到实处。

IDictionary<Type, IList<Func<object>>> Factories { get; set; }

突发性大家会想让用户在计划文件中切换落成项目,这时假使把键类型改成服务类型+字符串,落成起来会简单许多。
Resolve能够这么用:
Resolve<Service>(serviceKey: Configuration["ImplementationName"])

IDictionary<Tuple<Type, string>, IList<Func<object>>> Factories { get; set; }
类型 描述
Instance 任何时间都只能使用特定的实例对象,开发人员需要负责该对象的初始化工作。
Transient 每次都重新创建一个实例。
Singleton 创建一个单例,以后每次调用的时候都返回该单例对象。
Scoped 在当前作用域内,不管调用多少次,都是一个实例,换了作用域就会再次创建实例,类似于特定作用内的单例。
类型 描述
Instance 任何时间都只能使用特定的实例对象,开发人员需要负责该对象的初始化工作。
Transient 每次都重新创建一个实例。
Singleton 创建一个单例,以后每次调用的时候都返回该单例对象。
Scoped 在当前作用域内,不管调用多少次,都是一个实例,换了作用域就会再次创建实例,类似于特定作用内的单例。

勘误容器的构想 – Register和Resolve的管理

在分明了索引类型后,RegisterResolve的拍卖都应有跟着改造。
Register注册时应当首先依据兑现项目退换工厂函数,再把工厂函数加到服务类型对应的列表中。
Resolve解决期应该依据服务类型找到工厂函数,然后试行工厂函数重临实例。

改善容器的构想 – Register和Resolve的拍卖

在明显了索引类型后,RegisterResolve的管理都应有跟着转移。
Register注册时应当首先依据贯彻项目改换工厂函数,再把工厂函数加到服务类型对应的列表中。
Resolve消除时应该依靠服务类型找到工厂函数,然后施行工厂函数再次回到实例。

类别注册与示范

借助注入类型的注册一般是在程序运维的入口中,如Startup.cs中的ConfigureServices中,该类的根本目的正是登记信赖注入的系列。由于依赖注入的关键反映是接口编制程序,所以本例中,小编以接口和达成类的主意来比喻。

首先声惠氏(WYETH)个接口ITodoRepository和促成类TodoRepository1,代码如下:

public interface ITodoRepository
{
    IEnumerable<TodoItem> AllItems { get; }
    void Add(TodoItem item);
    TodoItem GetById(int id);
    bool TryDelete(int id);
}

public class TodoItem
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class TodoRepository : ITodoRepository
{
    readonly List<TodoItem> _items = new List<TodoItem>();

    public IEnumerable<TodoItem> AllItems
    {
        get { return _items; }
    }

    public TodoItem GetById(int id)
    {
        return _items.FirstOrDefault(x => x.Id == id);
    }

    public void Add(TodoItem item)
    {
        item.Id = 1 + _items.Max(x => (int?)x.Id) ?? 0;
        _items.Add(item);
    }

    public bool TryDelete(int id)
    {
        var item = GetById(id);

        if (item == null) { return false; }

        _items.Remove(item);

        return true;
    }
}

为了演示差别的扬言周期类型,提议多落成多少个类,比方TodoRepository二、TodoRepository三、TodoRepository肆等,以便进行出现说法。

下一场在ConfigureServices方法内注册接口ITodoRepository类型和相应的贯彻类,本例中依照不一样的生命周期注册了差异的落到实处类,具体示举个例子下:

//注册单例模式,整个应用程序周期内ITodoRepository接口的示例都是TodoRepository1的一个单例实例
services.AddSingleton<ITodoRepository, TodoRepository1>();
services.AddSingleton(typeof(ITodoRepository), typeof(TodoRepository1));  // 等价形式

//注册特定实例模型,整个应用程序周期内ITodoRepository接口的示例都是固定初始化好的一个单例实例

TodoRepository2
services.AddInstance<ITodoRepository>(new TodoRepository2());
services.AddInstance(typeof(ITodoRepository), new TodoRepository2());  // 等价形式

//注册作用域型的类型,在特定作用域内ITodoRepository的示例是TodoRepository3
services.AddScoped<ITodoRepository, TodoRepository3>();
services.AddScoped(typeof(ITodoRepository), typeof(TodoRepository3));// 等价形式

//获取该ITodoRepository实例时,每次都要实例化一次TodoRepository4类
services.AddTransient<ITodoRepository, TodoRepository4>();
services.AddTransient(typeof(ITodoRepository), typeof(TodoRepository));// 等价形式

//如果要注入的类没有接口,那你可以直接注入自身类型,比如:
services.AddTransient<LoggingHelper>();

借助注入的在MVC中的使用办法当下有三种,分别是Controller的构造函数、属性以及View中的Inject情势。当中构造函数注入和事先的MVC中的是同等的,示例代码如下:

public class TodoController : Controller
{
    private readonly ITodoRepository _repository;

    /// 依赖注入框架会自动找到ITodoRepository实现类的示例,赋值给该构造函数
    public TodoController(ITodoRepository repository)
    {
        _repository = repository;
    }

    [HttpGet]
    public IEnumerable<TodoItem> GetAll()
    {
        return _repository.AllItems;  //这里就可以使用该对象了
    }
}

本性注入,则是经过在性质上加二个[FromServices]质量就可以完毕自动得到实例。

public class TodoController : Controller
{
    // 依赖注入框架会自动找到ITodoRepository实现类的示例,赋值给该属性
    [FromServices]
    public ITodoRepository Repository { get; set; }

    [HttpGet]
    public IEnumerable<TodoItem> GetAll()
    {
        return Repository.AllItems;
    }
}

在意:那种办法,近日只适用于Controller以及子类,不适用于普通类
再者:通过那种方式,你能够拿走到越来越多的类别实例对象,如ActionContextHttpContextHttpRequestHttpResponse
ViewDataDictionary、以及ActionBindingContext

在视图中,则能够透过@inject首要字来完毕注入类型的实例提取,示比方下:

@using WebApplication1
@inject ITodoRepository repository
<div>
    @repository.AllItems.Count()
</div>

而最相似的选拔方法,则是赢得IServiceProvider的实例,获取该IServiceProvider实例的主意当下有如下两种(但范围不相同):

var provider1 = this.Request.HttpContext.ApplicationServices; 当前应用程序里注册的Service
var provider2 = Context.RequestServices;  // Controller中,当前请求作用域内注册的Service
var provider3 = Resolver; //Controller中

下一场经过GetService和GetRequiredService方法来获取钦命项目的实例,示举例下:

var _repository1 = provider1.GetService(typeof(ITodoRepository));
var _repository2 = provider1.GetService<LoggingHelper>();//等价形式
//上述2个对象可能为空

var _repository3 = provider1.GetRequiredService(typeof(ITodoRepository));
var _repository4 = provider1.GetRequiredService<LoggingHelper>();//等价形式
//上述2个对象肯定不为空,因为如果为空的话,会自动抛异常出来

连串注册与示范

依靠注入类型的注册一般是在程序运维的入口中,如Startup.cs中的ConfigureServices中,该类的首要目标就是登记依赖注入的花色。由于正视注入的显要反映是接口编制程序,所以本例中,小编以接口和兑现类的不二等秘书籍来比喻。

首先声雀巢(Nestle)(Beingmate)个接口ITodoRepository和达成类TodoRepository一,代码如下:

public interface ITodoRepository{    IEnumerable<TodoItem> AllItems { get; }    void Add(TodoItem item);    TodoItem GetById;    bool TryDelete;}public class TodoItem{    public int Id { get; set; }    public string Name { get; set; }}public class TodoRepository : ITodoRepository{    readonly List<TodoItem> _items = new List<TodoItem>();    public IEnumerable<TodoItem> AllItems    {        get { return _items; }    }    public TodoItem GetById    {        return _items.FirstOrDefault(x => x.Id == id);    }    public void Add(TodoItem item)    {        item.Id = 1 + _items.Max(x => x.Id) ?? 0;        _items.Add;    }    public bool TryDelete    {        var item = GetById;        if (item == null) { return false; }        _items.Remove;        return true;    }}

为了演示分歧的扬言周期类型,建议多达成多少个类,举个例子TodoRepository二、TodoRepository三、TodoRepository四等,以便举办出现说法。

下一场在ConfigureServices方法内注册接口ITodoRepository类型和相应的贯彻类,本例中遵照不一致的生命周期注册了差别的落到实处类,具体示举例下:

//注册单例模式,整个应用程序周期内ITodoRepository接口的示例都是TodoRepository1的一个单例实例services.AddSingleton<ITodoRepository, TodoRepository1>();services.AddSingleton(typeof(ITodoRepository), typeof(TodoRepository1));  // 等价形式//注册特定实例模型,整个应用程序周期内ITodoRepository接口的示例都是固定初始化好的一个单例实例TodoRepository2services.AddInstance<ITodoRepository>(new TodoRepository2;services.AddInstance(typeof(ITodoRepository), new TodoRepository2;  // 等价形式//注册作用域型的类型,在特定作用域内ITodoRepository的示例是TodoRepository3services.AddScoped<ITodoRepository, TodoRepository3>();services.AddScoped(typeof(ITodoRepository), typeof(TodoRepository3));// 等价形式//获取该ITodoRepository实例时,每次都要实例化一次TodoRepository4类services.AddTransient<ITodoRepository, TodoRepository4>();services.AddTransient(typeof(ITodoRepository), typeof(TodoRepository));// 等价形式//如果要注入的类没有接口,那你可以直接注入自身类型,比如:services.AddTransient<LoggingHelper>();

借助注入的在MVC中的使用办法当下有三种,分别是Controller的构造函数、属性以及View中的Inject情势。其中构造函数注入和事先的MVC中的是同等的,示例代码如下:

public class TodoController : Controller{    private readonly ITodoRepository _repository;    /// 依赖注入框架会自动找到ITodoRepository实现类的示例,赋值给该构造函数    public TodoController(ITodoRepository repository)    {        _repository = repository;    }    [HttpGet]    public IEnumerable<TodoItem> GetAll()    {        return _repository.AllItems;  //这里就可以使用该对象了    }}

本性注入,则是经过在性质上加贰个[FromServices]性子就可以实现自动得到实例。

public class TodoController : Controller{    // 依赖注入框架会自动找到ITodoRepository实现类的示例,赋值给该属性    [FromServices]    public ITodoRepository Repository { get; set; }    [HttpGet]    public IEnumerable<TodoItem> GetAll()    {        return Repository.AllItems;    }}

专注:那种办法,目前只适用于Controller以及子类,不适用于普通类
同时:通过那种方法,你能够博得到越多的系统实例对象,如ActionContextHttpContextHttpRequestHttpResponse
ViewDataDictionary、以及ActionBindingContext

在视图中,则能够透过@inject注重字来兑现注入类型的实例提取,示比方下:

@using WebApplication1@inject ITodoRepository repository<div>    @repository.AllItems.Count()</div>

而最相似的采取办法,则是获取IServiceProvider的实例,获取该IServiceProvider实例的格局当下有如下二种:

var provider1 = this.Request.HttpContext.ApplicationServices; 当前应用程序里注册的Servicevar provider2 = Context.RequestServices;  // Controller中,当前请求作用域内注册的Servicevar provider3 = Resolver; //Controller中

下一场经过GetService和GetRequiredService方法来得到钦命项目标实例,示比方下:

var _repository1 = provider1.GetService(typeof(ITodoRepository));var _repository2 = provider1.GetService<LoggingHelper>();//等价形式//上述2个对象可能为空var _repository3 = provider1.GetRequiredService(typeof(ITodoRepository));var _repository4 = provider1.GetRequiredService<LoggingHelper>();//等价形式//上述2个对象肯定不为空,因为如果为空的话,会自动抛异常出来

创新后的容器

以此容器新增添了1个ResolveMany函数,用于缓慢解决多少个实例。
此外还用了Expression.Lambda编写翻译工厂函数,生效能率会比Activator.CreateInstance快数十倍。

public class Container
{
    private IDictionary<Tuple<Type, string>, IList<Func<object>>> Factories { get; set; }

    public Container()
    {
        Factories = new Dictionary<Tuple<Type, string>, IList<Func<object>>>();
    }

    public void Register<TImplementation, TService>(string serviceKey = null)
        where TImplementation : TService
    {
        var key = Tuple.Create(typeof(TService), serviceKey);
        IList<Func<object>> factories;
        if (!Factories.TryGetValue(key, out factories))
        {
            factories = new List<Func<object>>();
            Factories[key] = factories;
        }
        var factory = Expression.Lambda<Func<object>>(Expression.New(typeof(TImplementation))).Compile();
        factories.Add(factory);
    }

    public TService Resolve<TService>(string serviceKey = null)
    {
        var key = Tuple.Create(typeof(TService), serviceKey);
        var factory = Factories[key].Single();
        return (TService)factory();
    }

    public IEnumerable<TService> ResolveMany<TService>(string serviceKey = null)
    {
        var key = Tuple.Create(typeof(TService), serviceKey);
        IList<Func<object>> factories;
        if (!Factories.TryGetValue(key, out factories))
        {
            yield break;
        }
        foreach (var factory in factories)
        {
            yield return (TService)factory();
        }
    }
}

创新后的容器还是有以下的标题

  • 一直不对实例进行生命周期管理
  • 未有得以落成构造函数注入

千锤百炼后的容器

其1容器新增了二个ResolveMany函数,用于缓和多少个实例。
其它还用了Expression.Lambda编写翻译工厂函数,生效用率会比Activator.CreateInstance快数10倍。

public class Container
{
    private IDictionary<Tuple<Type, string>, IList<Func<object>>> Factories { get; set; }

    public Container()
    {
        Factories = new Dictionary<Tuple<Type, string>, IList<Func<object>>>();
    }

    public void Register<TImplementation, TService>(string serviceKey = null)
        where TImplementation : TService
    {
        var key = Tuple.Create(typeof(TService), serviceKey);
        IList<Func<object>> factories;
        if (!Factories.TryGetValue(key, out factories))
        {
            factories = new List<Func<object>>();
            Factories[key] = factories;
        }
        var factory = Expression.Lambda<Func<object>>(Expression.New(typeof(TImplementation))).Compile();
        factories.Add(factory);
    }

    public TService Resolve<TService>(string serviceKey = null)
    {
        var key = Tuple.Create(typeof(TService), serviceKey);
        var factory = Factories[key].Single();
        return (TService)factory();
    }

    public IEnumerable<TService> ResolveMany<TService>(string serviceKey = null)
    {
        var key = Tuple.Create(typeof(TService), serviceKey);
        IList<Func<object>> factories;
        if (!Factories.TryGetValue(key, out factories))
        {
            yield break;
        }
        foreach (var factory in factories)
        {
            yield return (TService)factory();
        }
    }
}

校对后的器皿仍旧有以下的标题

  • 从未对实例进行生命周期管理
  • 并未有落到实处构造函数注入

普通类的借助注入

在新版的ASP.NET5中,不仅协助方面大家所说的接口类的借助注入,还帮衬一般的品类的注重性注入,举例大家生命1个普通类,示举例下:

public class AppSettings
{
    public string SiteTitle { get; set; }
}

上述普通类要确定保证有无参数构造函数,那么注册的用法,就活该像如下那样:

services.Configure<AppSettings>(app =>
{
    app.SiteTitle = "111";
});

行使的时候,则须求得到IOptions<AppSettings>品种的实例,然后其Options属性就是AppSettings的实例,代码如下:

var appSettings = app.ApplicationServices.GetRequiredService<IOptions<AppSettings>>().Options;

理所当然,大家也得以在视图中,使用@inject语法来博取实例,示例代码如下:

@inject IOptions<AppSettings> AppSettings

<title>@AppSettings.Options.SiteTitle</title>

普通类的依赖注入

在新版的ASP.NET5中,不仅帮忙地点咱们所说的接口类的信赖注入,还支持普通的档次的依赖注入,比方大家生命一个普通类,示举个例子下:

public class AppSettings{    public string SiteTitle { get; set; }}

上述普通类要有限援救有无参数构造函数,那么注册的用法,就相应像如下那样:

services.Configure<AppSettings>(app =>{    app.SiteTitle = "111";});

运用的时候,则必要得到IOptions<AppSettings>项目标实例,然后其Options属性正是AppSettings的实例,代码如下:

var appSettings = app.ApplicationServices.GetRequiredService<IOptions<AppSettings>>().Options;

本来,大家也能够在视图中,使用@inject语法来获得实例,示例代码如下:

@inject IOptions<AppSettings> AppSettings<title>@AppSettings.Options.SiteTitle</title>

福如东海实例的单例

以上面代码为例

var logger_a = container.Resolve<ILogger>();
var logger_b = container.Resolve<ILogger>();

利用方面的器皿实践那段代码时,logger_alogger_b是多个例外的靶子,若是想要每便Resolve都回去同样的目的啊?
大家能够对工厂函数进行李包裹装,借助闭包(Closure)的力量能够卓殊轻易的落到实处。

private Func<object> WrapFactory(Func<object> originalFactory, bool singleton)
{
    if (!singleton)
        return originalFactory;
    object value = null;
    return () =>
    {
        if (value == null)
            value = originalFactory();
        return value;
    };
}

增加这些函数后在Register中调用factory = WrapFactory(factory, singleton);即可。
全体代码就要后头放出,接下去再看什么落到实处构造函数注入。

完成实例的单例

以上面代码为例

var logger_a = container.Resolve<ILogger>();
var logger_b = container.Resolve<ILogger>();

动用方面的容器实践那段代码时,logger_alogger_b是五个不等的目的,借使想要每回Resolve都回来同样的目的呢?
作者们能够对工厂函数实行打包,借助闭包(Closure)的力量能够相当简单的达成。

private Func<object> WrapFactory(Func<object> originalFactory, bool singleton)
{
    if (!singleton)
        return originalFactory;
    object value = null;
    return () =>
    {
        if (value == null)
            value = originalFactory();
        return value;
    };
}

增加那几个函数后在Register中调用factory = WrapFactory(factory, singleton);即可。
全部代码将要背后放出,接下去再看什么得以落成构造函数注入。

听他们说Scope生命周期的依赖注入

依赖Scope生命周期的借助注入

福寿绵绵构造函数注入

以上面代码为例

public class MyLogWriter : ILogWriter
{
    public void Write(string str)
    {
        Console.WriteLine(str);
    }
}

public class MyLogger : ILogger
{
    ILogWriter _writer;

    public MyLogger(ILogWriter writer)
    {
        _writer = writer;
    }

    public void Log(string message)
    {
        _writer.Write("[ Log ] " + message);
    }
}

static void Main(string[] args)
{
    var container = new Container();
    container.Register<MyLogWriter, ILogWriter>();
    container.Register<MyLogger, ILogger>();

    var logger = container.Resolve<ILogger>();
    logger.Log("Example Message");
}

在那段代码中,MyLogger结构时索要一个ILogWriter的实例,但是这些实例我们无法平昔传给它。
那般将要求容器能够自动生成ILogWriter的实例,再传给MyLogger以生成MyLogger的实例。
要贯彻这些效果必要使用c#中的反射机制。

把地点代码中的

var factory = Expression.Lambda<Func<object>>(Expression.New(typeof(TImplementation))).Compile();

换成

private Func<object> BuildFactory(Type type)
{
    // 获取类型的构造函数
    var constructor = type.GetConstructors().FirstOrDefault();
    // 生成构造函数中的每个参数的表达式
    var argumentExpressions = new List<Expression>();
    foreach (var parameter in constructor.GetParameters())
    {
        var parameterType = parameter.ParameterType;
        if (parameterType.IsGenericType &&
            parameterType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
        {
            // 等于调用this.ResolveMany<TParameter>();
            argumentExpressions.Add(Expression.Call(
                Expression.Constant(this), "ResolveMany",
                parameterType.GetGenericArguments(),
                Expression.Constant(null, typeof(string))));
        }
        else
        {
            // 等于调用this.Resolve<TParameter>();
            argumentExpressions.Add(Expression.Call(
                Expression.Constant(this), "Resolve",
                new [] { parameterType },
                Expression.Constant(null, typeof(string))));
        }
    }
    // 构建new表达式并编译到委托
    var newExpression = Expression.New(constructor, argumentExpressions);
    return Expression.Lambda<Func<object>>(newExpression).Compile();
}

那段代码通过反射获取了构造函数中的全数参数,并对每种参数使用ResolveResolveMany解决。
值得注意的是参数的缓慢解决是延迟的,唯有在营造MyLogger的时候才会构建MyLogWriter,这样做的补益是流入的实例不自然需倘使单例。
用表明式创设的厂子函数消除的时候的性质会非常高。

贯彻构造函数注入

以下边代码为例

public class MyLogWriter : ILogWriter
{
    public void Write(string str)
    {
        Console.WriteLine(str);
    }
}

public class MyLogger : ILogger
{
    ILogWriter _writer;

    public MyLogger(ILogWriter writer)
    {
        _writer = writer;
    }

    public void Log(string message)
    {
        _writer.Write("[ Log ] " + message);
    }
}

static void Main(string[] args)
{
    var container = new Container();
    container.Register<MyLogWriter, ILogWriter>();
    container.Register<MyLogger, ILogger>();

    var logger = container.Resolve<ILogger>();
    logger.Log("Example Message");
}

在那段代码中,MyLogger结构时索要1个ILogWriter的实例,可是这几个实例大家不能够直接传给它。
如此将须要容器能够自动生成ILogWriter的实例,再传给MyLogger以生成MyLogger的实例。
要促成那些职能供给使用c#中的反射机制。

把上面代码中的

var factory = Expression.Lambda<Func<object>>(Expression.New(typeof(TImplementation))).Compile();

换成

private Func<object> BuildFactory(Type type)
{
    // 获取类型的构造函数
    var constructor = type.GetConstructors().FirstOrDefault();
    // 生成构造函数中的每个参数的表达式
    var argumentExpressions = new List<Expression>();
    foreach (var parameter in constructor.GetParameters())
    {
        var parameterType = parameter.ParameterType;
        if (parameterType.IsGenericType &&
            parameterType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
        {
            // 等于调用this.ResolveMany<TParameter>();
            argumentExpressions.Add(Expression.Call(
                Expression.Constant(this), "ResolveMany",
                parameterType.GetGenericArguments(),
                Expression.Constant(null, typeof(string))));
        }
        else
        {
            // 等于调用this.Resolve<TParameter>();
            argumentExpressions.Add(Expression.Call(
                Expression.Constant(this), "Resolve",
                new [] { parameterType },
                Expression.Constant(null, typeof(string))));
        }
    }
    // 构建new表达式并编译到委托
    var newExpression = Expression.New(constructor, argumentExpressions);
    return Expression.Lambda<Func<object>>(newExpression).Compile();
}

这段代码通过反射获取了构造函数中的全部参数,并对各样参数使用ResolveResolveMany解决。
值得注意的是参数的缓和是延迟的,唯有在创设MyLogger的时候才会营造MyLogWriter,那样做的收益是流入的实例不自然需就算单例。
用表达式营造的工厂函数化解的时候的属性会相当高。

一般性的Scope依赖注入

依据Scope成效域的实例在开立的时候须求先创造功用域,然后在该成效域内再获得特定的实例,我们看看3个演示并对其张开认证。首先,注册重视注入类型,代码如下:

services.AddScoped<ITodoRepository, TodoRepository>();

然后创建功能域,并在该成效域内获取实例:

var serviceProvider = Resolver;

var scopeFactory = serviceProvider.GetService<IServiceScopeFactory>(); //获取Scope工厂类
using (var scope = scopeFactory.CreateScope())  // 创建一个Scope作用域
{
    var containerScopedService = serviceProvider.GetService<ITodoRepository>();  //获取普通的实例
    var scopedService1 = scope.ServiceProvider.GetService<ITodoRepository>(); //获取当前Scope的实例
    Thread.Sleep(200);
    var scopedService2 = scope.ServiceProvider.GetService<ITodoRepository>(); //获取当前Scope的实例

    Console.WriteLine(containerScopedService == scopedService1); // 输出:False
    Console.WriteLine(scopedService1 == scopedService2); //输出:True
}

除此以外,Scope也足以展开嵌套,嵌套的前后成效域所收获的实例也是不等同的,实例代码如下:

var serviceProvider = Resolver;

var outerScopeFactory = serviceProvider.GetService<IServiceScopeFactory>();
using (var outerScope = outerScopeFactory.CreateScope()) //外部Scope作用域
{
    var innerScopeFactory = outerScope.ServiceProvider.GetService<IServiceScopeFactory>();
    using (var innerScope = innerScopeFactory.CreateScope()) //内部Scope作用域
    {
        var outerScopedService = outerScope.ServiceProvider.GetService<ITodoRepository>();
        var innerScopedService = innerScope.ServiceProvider.GetService<ITodoRepository>();

        Console.WriteLine(outerScopedService == innerScopedService); // 输出:False
    }
}

一般来讲的Scope注重注入

凭仗Scope功效域的实例在开创的时候须要先创建功能域,然后在该效用域内再获得一定的实例,大家看看二个示范并对其进行表达。首先,注册信赖注入类型,代码如下:

services.AddScoped<ITodoRepository, TodoRepository>();

接下来制造作用域,并在该效用域内获得实例:

var serviceProvider = Resolver;var scopeFactory = serviceProvider.GetService<IServiceScopeFactory>(); //获取Scope工厂类using (var scope = scopeFactory.CreateScope  // 创建一个Scope作用域{    var containerScopedService = serviceProvider.GetService<ITodoRepository>();  //获取普通的实例    var scopedService1 = scope.ServiceProvider.GetService<ITodoRepository>(); //获取当前Scope的实例    Thread.Sleep;    var scopedService2 = scope.ServiceProvider.GetService<ITodoRepository>(); //获取当前Scope的实例    Console.WriteLine(containerScopedService == scopedService1); // 输出:False    Console.WriteLine(scopedService1 == scopedService2); //输出:True}

此外,Scope也得以实行嵌套,嵌套的上下功效域所得到的实例也是差异等的,实例代码如下:

var serviceProvider = Resolver;var outerScopeFactory = serviceProvider.GetService<IServiceScopeFactory>();using (var outerScope = outerScopeFactory.CreateScope //外部Scope作用域{    var innerScopeFactory = outerScope.ServiceProvider.GetService<IServiceScopeFactory>();    using (var innerScope = innerScopeFactory.CreateScope //内部Scope作用域    {        var outerScopedService = outerScope.ServiceProvider.GetService<ITodoRepository>();        var innerScopedService = innerScope.ServiceProvider.GetService<ITodoRepository>();        Console.WriteLine(outerScopedService == innerScopedService); // 输出:False    }}

1体化代码

容器和演示的完好代码如下

public interface ILogWriter
{
    void Write(string text);
}

public class MyLogWriter : ILogWriter
{
    public void Write(string str)
    {
        Console.WriteLine(str);
    }
}

public interface ILogger
{
    void Log(string message);
}

public class MyLogger : ILogger
{
    ILogWriter _writer;

    public MyLogger(ILogWriter writer)
    {
        _writer = writer;
    }

    public void Log(string message)
    {
        _writer.Write("[ Log ] " + message);
    }
}

static void Main(string[] args)
{
    var container = new Container();
    container.Register<MyLogWriter, ILogWriter>();
    container.Register<MyLogger, ILogger>();
    var logger = container.Resolve<ILogger>();
    logger.Log("asdasdas");
}

public class Container
{
    private IDictionary<Tuple<Type, string>, IList<Func<object>>> Factories { get; set; }

    public Container()
    {
        Factories = new Dictionary<Tuple<Type, string>, IList<Func<object>>>();
    }

    private Func<object> WrapFactory(Func<object> originalFactory, bool singleton)
    {
        if (!singleton)
            return originalFactory;
        object value = null;
        return () =>
        {
            if (value == null)
                value = originalFactory();
            return value;
        };
    }

    private Func<object> BuildFactory(Type type)
    {
        // 获取类型的构造函数
        var constructor = type.GetConstructors().FirstOrDefault();
        // 生成构造函数中的每个参数的表达式
        var argumentExpressions = new List<Expression>();
        foreach (var parameter in constructor.GetParameters())
        {
            var parameterType = parameter.ParameterType;
            if (parameterType.IsGenericType &&
                parameterType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
            {
                // 等于调用this.ResolveMany<TParameter>();
                argumentExpressions.Add(Expression.Call(
                    Expression.Constant(this), "ResolveMany",
                    parameterType.GetGenericArguments(),
                    Expression.Constant(null, typeof(string))));
            }
            else
            {
                // 等于调用this.Resolve<TParameter>();
                argumentExpressions.Add(Expression.Call(
                    Expression.Constant(this), "Resolve",
                    new [] { parameterType },
                    Expression.Constant(null, typeof(string))));
            }
        }
        // 构建new表达式并编译到委托
        var newExpression = Expression.New(constructor, argumentExpressions);
        return Expression.Lambda<Func<object>>(newExpression).Compile();
    }

    public void Register<TImplementation, TService>(string serviceKey = null, bool singleton = false)
        where TImplementation : TService
    {
        var key = Tuple.Create(typeof(TService), serviceKey);
        IList<Func<object>> factories;
        if (!Factories.TryGetValue(key, out factories))
        {
            factories = new List<Func<object>>();
            Factories[key] = factories;
        }
        var factory = BuildFactory(typeof(TImplementation));
        WrapFactory(factory, singleton);
        factories.Add(factory);
    }

    public TService Resolve<TService>(string serviceKey = null)
    {
        var key = Tuple.Create(typeof(TService), serviceKey);
        var factory = Factories[key].Single();
        return (TService)factory();
    }

    public IEnumerable<TService> ResolveMany<TService>(string serviceKey = null)
    {
        var key = Tuple.Create(typeof(TService), serviceKey);
        IList<Func<object>> factories;
        if (!Factories.TryGetValue(key, out factories))
        {
            yield break;
        }
        foreach (var factory in factories)
        {
            yield return (TService)factory();
        }
    }
}

总体代码

容器和示范的1体化代码如下

public interface ILogWriter
{
    void Write(string text);
}

public class MyLogWriter : ILogWriter
{
    public void Write(string str)
    {
        Console.WriteLine(str);
    }
}

public interface ILogger
{
    void Log(string message);
}

public class MyLogger : ILogger
{
    ILogWriter _writer;

    public MyLogger(ILogWriter writer)
    {
        _writer = writer;
    }

    public void Log(string message)
    {
        _writer.Write("[ Log ] " + message);
    }
}

static void Main(string[] args)
{
    var container = new Container();
    container.Register<MyLogWriter, ILogWriter>();
    container.Register<MyLogger, ILogger>();
    var logger = container.Resolve<ILogger>();
    logger.Log("asdasdas");
}

public class Container
{
    private IDictionary<Tuple<Type, string>, IList<Func<object>>> Factories { get; set; }

    public Container()
    {
        Factories = new Dictionary<Tuple<Type, string>, IList<Func<object>>>();
    }

    private Func<object> WrapFactory(Func<object> originalFactory, bool singleton)
    {
        if (!singleton)
            return originalFactory;
        object value = null;
        return () =>
        {
            if (value == null)
                value = originalFactory();
            return value;
        };
    }

    private Func<object> BuildFactory(Type type)
    {
        // 获取类型的构造函数
        var constructor = type.GetConstructors().FirstOrDefault();
        // 生成构造函数中的每个参数的表达式
        var argumentExpressions = new List<Expression>();
        foreach (var parameter in constructor.GetParameters())
        {
            var parameterType = parameter.ParameterType;
            if (parameterType.IsGenericType &&
                parameterType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
            {
                // 等于调用this.ResolveMany<TParameter>();
                argumentExpressions.Add(Expression.Call(
                    Expression.Constant(this), "ResolveMany",
                    parameterType.GetGenericArguments(),
                    Expression.Constant(null, typeof(string))));
            }
            else
            {
                // 等于调用this.Resolve<TParameter>();
                argumentExpressions.Add(Expression.Call(
                    Expression.Constant(this), "Resolve",
                    new [] { parameterType },
                    Expression.Constant(null, typeof(string))));
            }
        }
        // 构建new表达式并编译到委托
        var newExpression = Expression.New(constructor, argumentExpressions);
        return Expression.Lambda<Func<object>>(newExpression).Compile();
    }

    public void Register<TImplementation, TService>(string serviceKey = null, bool singleton = false)
        where TImplementation : TService
    {
        var key = Tuple.Create(typeof(TService), serviceKey);
        IList<Func<object>> factories;
        if (!Factories.TryGetValue(key, out factories))
        {
            factories = new List<Func<object>>();
            Factories[key] = factories;
        }
        var factory = BuildFactory(typeof(TImplementation));
        WrapFactory(factory, singleton);
        factories.Add(factory);
    }

    public TService Resolve<TService>(string serviceKey = null)
    {
        var key = Tuple.Create(typeof(TService), serviceKey);
        var factory = Factories[key].Single();
        return (TService)factory();
    }

    public IEnumerable<TService> ResolveMany<TService>(string serviceKey = null)
    {
        var key = Tuple.Create(typeof(TService), serviceKey);
        IList<Func<object>> factories;
        if (!Factories.TryGetValue(key, out factories))
        {
            yield break;
        }
        foreach (var factory in factories)
        {
            yield return (TService)factory();
        }
    }
}

传说HTTP请求的Scope依赖注入

在头里大多风靡的DI容器中,针对每一个请求,在该请求成效域内保留3个单实例对象是很盛行的,也正是在历次请求时期一个项目的靶子实例只会创建1遍,那样能够大大升高质量。

在ASP.NET5中,基于HTTP请求的Scope正视注入是由此1个ContainerMiddleware来得以落成的,调用该Middleware时,会创立二个限制作用域的DI容器,用于替换当前恳求中已某些暗中认可DI容器。在该管线中,全部继续的Middleware都会利用那么些新的DI容器,在伸手走完全体Pipeline管线未来,该ContainerMiddleware的法力就终止了,此时功效域会被销毁,并且在该功用域内创立的实例对象也都会销毁释放。

ContainerMiddleware的时序图如下所示:

金沙注册送58 1

现实的施用办法如下:

app.Use(new Func<RequestDelegate, RequestDelegate>(nextApp => new ContainerMiddleware(nextApp, app.ApplicationServices).Invoke));

基于HTTP请求的Scope重视注入

在事先多数风靡的DI容器中,针对每一种请求,在该请求成效域内保留一个单实例对象是极红的,也正是在历次请求时期八个项目的目的实例只会成立2回,那样能够大大升高质量。

在ASP.NET5中,基于HTTP请求的Scope注重注入是由此二个ContainerMiddleware来实现的,调用该Middleware时,会创建二个限量成效域的DI容器,用于替换当前呼吁中已有的私下认可DI容器。在该管线中,全部继续的Middleware都会动用那一个新的DI容器,在呼吁走完全数Pipeline管线以往,该ContainerMiddleware的法力就停止了,此时效果域会被销毁,并且在该作用域内成立的实例对象也都会销毁释放。

ContainerMiddleware的时序图如下所示:

金沙注册送58 2

具体的施用方法如下:

app.Use(new Func<RequestDelegate, RequestDelegate>(nextApp => new ContainerMiddleware(nextApp, app.ApplicationServices).Invoke));

写在最后

其一容器落成了2个正视注入容器应该某些重大作用,不过如故有过多供不应求的地方,比如

  • 不帮衬线程安全
  • 不辅助非泛型的注册和化解
  • 不扶助只用于内定范围内的单例
  • 不协助成员注入
  • 不协理动态代理落成AOP

我在ZKWeb网页框架中也使用了协和编辑的器皿,唯有300多行不过足以满意实际项目的施用。
总体的源代码能够翻看这里和这里。

微软从.Net
Core开始提供了DependencyInjection的架空中接力口,那为借助注入提供了三个标准。
在以后恐怕不会再须要上学Castle 温莎,
Autofac等,而是一贯选用微软提供的规范接口。
固然如此具体的得以完毕格局离我们原来越远,可是驾驭一下它们的法则总是有便宜的。

写在终极

其1容器完成了二个借助注入容器应该某个重大职能,可是依旧有成都百货上千相差的地点,比如

  • 不援助线程安全
  • 不帮忙非泛型的登记和平消除决
  • 不支持只用于内定范围内的单例
  • 不援助成员注入
  • 不扶助动态代理达成AOP

我在ZKWeb网页框架中也运用了和煦编排的容器,只有300多行不过足以满意实际项目的施用。
1体化的源代码能够查阅那里和这里。

微软从.Net
Core初阶提供了DependencyInjection的空洞接口,那为借助注入提供了3个正式。
在前日说不定不会再必要上学Castle 温莎,
Autofac等,而是直接使用微软提供的标准接口。
就算如此实际的落成格局离我们原来越远,可是精通一下它们的原理总是有裨益的。

普通类的依赖注入管理

眼下普通类的依赖性注入,只扶助构造函数,比如我们定于3个TestService类,代码如下:

public class TestService
{
    private ITodoRepository _repository;
    public TestService(ITodoRepository r)
    {
        _repository = r;
    }

    public void Show()
    {
        Console.WriteLine(_repository.AllItems);
    }
}

透过在构造函数里传开ITodoRepository类的参数来利用该实例,使用的时候要求先将此类注册到DI容器中,代码如下:

services.AddScoped<ITodoRepository, TodoRepository>();
services.AddSingleton<TestService>();

然后调用如下语句就可以使用:

var service = serviceProvider.GetRequiredService<TestService>();

除此以外,须要专注,在最近的情景下,无法应用[FromServices]来行使信赖注入成效,举例,如下代码在赢得TestService2实例的历程中会出现错误:

public class TestService2
{
    [FromServices]
    public ITodoRepository Repository { get; set; }
    public void Show()
    {
        Console.WriteLine(Repository.AllItems);
    }
}

普通类的依据注入管理

时下普通类的借助注入,只辅助构造函数,举个例子大家定于一个TestService类,代码如下:

public class TestService{    private ITodoRepository _repository;    public TestService(ITodoRepository r)    {        _repository = r;    }    public void Show()    {        Console.WriteLine(_repository.AllItems);    }}

透过在构造函数里流传ITodoRepository类的参数来利用该实例,使用的时候需求先将此类注册到DI容器中,代码如下:

services.AddScoped<ITodoRepository, TodoRepository>();services.AddSingleton<TestService>();

然后调用如下语句就可以使用:

var service = serviceProvider.GetRequiredService<TestService>();

除此以外,必要专注,在现阶段的情事下,不能够运用[FromServices]来行使重视注入作用,比方,如下代码在赢得TestService2实例的经过中会出现谬误:

public class TestService2{    [FromServices]    public ITodoRepository Repository { get; set; }    public void Show()    {        Console.WriteLine(Repository.AllItems);    }}

通常类中获取HttpContext实例

在MVC陆中,我们无法通过HttpContent.Current来获得上下文对象了,所以在一般类中行使的时候就会出难题,要想在平日类中动用该上下文对象,须求经过注重注入来博取HttpContext实例,微软在ASP.NET5中,提供了IHttpContextAccessor接口用于获取该上下文对象。也等于说,大家能够将该类型的参数放在构造函数中,以赢得上下文实例,代码如下:

public class TestService3
{
    private IHttpContextAccessor _httpContextAccessor;
    public TestService3(IHttpContextAccessor httpContextAccessor)
    {
        _httpContextAccessor = httpContextAccessor;
    }

    public void Show()
    {
        var httpContext = _httpContextAccessor.HttpContext;//获取上下文对象实例
        Console.WriteLine(httpContext.Request.Host.Value);
    }
}

而利用的时候,则一向通过如下语句就能够了,代码如下:

var service = serviceProvider.GetRequiredService<TestService3>();
service.Show();

唤醒:普通类的构造函数中,能够流传五个DI容器支持的多寡类似作为参数。

万般类中获得HttpContext实例

在MVC六中,大家不可能通过HttpContent.Current来收获上下文对象了,所以在一般类中动用的时候就会出标题,要想在平常类中接纳该上下文对象,须求经过重视注入来得到HttpContext实例,微软在ASP.NET5中,提供了IHttpContextAccessor接口用于获取该上下文对象。相当于说,我们得以将该项目标参数放在构造函数中,以获得上下文实例,代码如下:

public class TestService3{    private IHttpContextAccessor _httpContextAccessor;    public TestService3(IHttpContextAccessor httpContextAccessor)    {        _httpContextAccessor = httpContextAccessor;    }    public void Show()    {        var httpContext = _httpContextAccessor.HttpContext;//获取上下文对象实例        Console.WriteLine(httpContext.Request.Host.Value);    }}

而利用的时候,则直接通过如下语句就可以了,代码如下:

var service = serviceProvider.GetRequiredService<TestService3>();service.Show();

提示:普通类的构造函数中,能够流传两个DI容器协助的数码类似作为参数。

使用第3方DI容器

眼下,.NETCore不协理,只还好全职能版的.NET
framework上才能选取,所以选取的时候需求专注一下。第3方DI容器的更迭经常是在Startup.cs的Configure方法中开始展览的,在章程的启幕处举行沟通,以便后续的Middleware会使用相关的借助注入效能。

第二要引进第②方的器皿,以Autofac为例,引进Microsoft.Framework.DependencyInjection.Autofac,然后进入如下示例中的替换代码就能够:

app.UseServices(services =>
{
    services.AddMvc();// AddMvc要在这里注册
    var builder = new ContainerBuilder();// 构造容器构建类
    builder.Populate(services);//将现有的Services路由到Autofac的管理集合中
    IContainer container = builder.Build();
    return container.Resolve<IServiceProvider>();//返回AutoFac实现的IServiceProvider
});

在意,使用上述方式的时候,要把Mvc的登记代码services.AddMvc();不能不要从ConfigureServices中挪到该表明式内,不然会报万分,等待微软消除。

除此以外,还有三个形式,微软脚下的实例项目中还尚未公开,通过分析部分代码,大家得以窥见,在Microsoft.AspNet.Hosting次第中的StartupLoader.cs顶住程序入口点的施行,在该文件中,我们知道首先是调用Startup.cs中的ConfigureServices主意,然后再调用Configure艺术;大家能够观望示例中的ConfigureServices的重回值是void类型的,但在源码分析中发掘,在依照约定解析ConfigureServices艺术的时候,其首先判别有未有再次来到类型是IServiceProvider的,假设有则实行该方法,用利用该再次来到中回到的新IServiceProvider实例;未有的话,再持续查找void类型的ConfigureServices办法。所以,大家可以透过那种措施,来替换第2方的DI容器,实例代码如下:

// 需要先删除void类型的ConfigureServices方法
public IServiceProvider ConfigureServices(IServiceCollection services)
{
    var builder = new ContainerBuilder();  // 构造容器构建类
    builder.Populate(services);  //将现有的Services路由到Autofac的管理集合中
    IContainer container = builder.Build();
    return container.Resolve<IServiceProvider>(); //返回AutoFac实现的IServiceProvider
}

那样,你就可以像往常同样,使用Autofac的法子开始展览重视类型的管理了,示比方下:

public class AutofacModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.Register(c => new Logger())
            .As<ILogger>()
            .InstancePerLifetimeScope();

        builder.Register(c => new ValuesService(c.Resolve<ILogger>()))
            .As<IValuesService>()
            .InstancePerLifetimeScope();
    }
}

地址:
其它一个关于Autofac集成的案例:

使用第三方DI容器

当前,.NETCore不支持,只可以在专职能版的.NET
framework上中国人民解放军海军事工业程学院业夫运用,所以采取的时候须求专注一下。第2方DI容器的更迭日常是在Startup.cs的Configure方法中张开的,在章程的发轫处进行轮换,以便后续的Middleware会使用相关的信赖注入作用。

第2要引进第壹方的容器,以Autofac为例,引进Microsoft.Framework.DependencyInjection.Autofac,然后参预如下示例中的替换代码就可以:

app.UseServices(services =>{    services.AddMvc();// AddMvc要在这里注册    var builder = new ContainerBuilder();// 构造容器构建类    builder.Populate;//将现有的Services路由到Autofac的管理集合中    IContainer container = builder.Build();    return container.Resolve<IServiceProvider>();//返回AutoFac实现的IServiceProvider});

小心,使用上述格局的时候,要把Mvc的挂号代码services.AddMvc();不能够不要从ConfigureServices中挪到该表明式内,不然会报非凡,等待微软消除。

此外,还有二个艺术,微软近日的实例项目中还并未有当面,通过分析部分代码,大家能够发掘,在Microsoft.AspNet.Hosting先后中的StartupLoader.cs负担程序入口点的举行,在该公文中,大家领略首先是调用Startup.cs中的ConfigureServices办法,然后再调用Configure措施;我们得以看出示例中的ConfigureServices的再次来到值是void类型的,但在源码分析中发觉,在依据预订解析ConfigureServices措施的时候,其首先推断有未有再次回到类型是IServiceProvider的,假使有则进行该办法,用利用该重临中回到的新IServiceProvider实例;未有的话,再持续搜寻void类型的ConfigureServices方法。所以,大家得以由此那种措施,来替换第1方的DI容器,实例代码如下:

// 需要先删除void类型的ConfigureServices方法public IServiceProvider ConfigureServices(IServiceCollection services){    var builder = new ContainerBuilder();  // 构造容器构建类    builder.Populate;  //将现有的Services路由到Autofac的管理集合中    IContainer container = builder.Build();    return container.Resolve<IServiceProvider>(); //返回AutoFac实现的IServiceProvider}

诸如此类,你就足以像往常同样,使用Autofac的方法进行依赖类型的管制了,示比如下:

public class AutofacModule : Module{    protected override void Load(ContainerBuilder builder)    {        builder.Register(c => new Logger            .As<ILogger>()            .InstancePerLifetimeScope();        builder.Register(c => new ValuesService(c.Resolve<ILogger>            .As<IValuesService>()            .InstancePerLifetimeScope();    }}

地址:
其余三个有关Autofac集成的案例:

最棒推行

在采取注重注入的的时候,大家应该遵从如下最棒实践。

  1. 做任何事情在此以前,务必在先后入口点提前注册全体的正视性类型。
  2. 制止间接行使IServiceProvider接口,相反,在构造函数里显式增多须求借助的品类就可以,让注重注入引擎自个儿来分析实例,壹旦注重很难管理以来,就应用抽象工厂。
  3. 基于接口举办编制程序,而不是基于落成进行编制程序。

参考1:
参考2:

最好施行

在采纳注重注入的的时候,大家应该遵循如下最棒实施。

  1. 做别的业务之前,务必在先后入口点提前注册全部的重视性类型。
  2. 幸免直接使用IServiceProvider接口,相反,在构造函数里显式增加需求依靠的门类就可以,让重视注入引擎本身来分析实例,1旦正视很难管理的话,就选拔抽象工厂。
  3. 依靠接口举办编制程序,而不是依据达成实行编制程序。

参考1:
参考2:

手拉手与推荐介绍

本文已联手至目录索引:解读ASP.NET 5 &
MVC6系列

共同与推荐

本文已联合至目录索引:解读ASP.NET 伍 & MVC6类别

相关文章

网站地图xml地图