什么编写三个简便的重视性注入容器,正视注入

乘势大面积的项目越多,大多种类都引进了依靠注入框架,个中最盛行的有Castle
温泽, Autofac和Unity Container。
微软在风靡版的Asp.Net
Core中自带了借助注入的功能,有乐趣能够查看那里。
至于怎样是依靠注入容器网樱笋时经有多数的文章介绍,那里小编将首要讲述怎么样贯彻三个祥和的器皿,可以协助您理解正视注入的原理。

乘胜周围的品种进一步多,诸多门类都引进了正视注入框架,个中最风靡的有Castle
温莎, Autofac和Unity Container。
微软在风行版的Asp.Net
Core中自带了依靠注入的效果,有意思味能够翻看那里。
至于怎么样是借助注入容器网上壹度有成千上万的作品介绍,这里自身将重点讲述怎么样完结贰个要好的容器,能够支持您知道注重注入的规律。

在日前的章节(Middleware章节)中,大家提到了正视注入作用(Dependency
Injection),ASP.NET
伍正式将凭借注入实行了全职能的得以落成,以便开荒人士能够开拓更具弹性的机件程序,MVC陆也运用了依赖注入的意义重新对Controller和View的劳务注入作用举办了再度规划;现在的信赖性注入作用还或然提供越来越多的API,全部要是还未有从头接触注重注入的话,就得好好学一下了。

在前边的章节(Middleware章节)中,我们提到了借助注入功用(Dependency
Injection),ASP.NET
5正式将依靠注入举行了专职能的贯彻,以便开辟人士能够开辟更具弹性的零部件程序,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、SignalRAV4、Entity
Framrwork等都注重于依靠注入的IServiceProvider接口,针对该接口微软提交了默许的达成ServiceProvider,以及Ninject和AutoFac版本的包裹,当然你也能够行使此外第1方的重视性注入容器,如Castle
温莎等;1旦采纳了第二方容器,全部的信赖解析都会被路由到该第三方容器上。

在事先版本的依靠注入功用里,正视注入的进口有MVC中的IControllerFactory和Web
API中的IHttpControllerActivator中,在新版ASP.NET5中,注重注入变成了最尾巴部分的基础支撑,MVC、Routing、Signal宝马7系、Entity
Framrwork等都依靠于依靠注入的IServiceProvider接口,针对该接口微软提交了暗许的达成ServiceProvider,以及Ninject和AutoFac版本的卷入,当然你也足以应用别的第三方的依赖性注入容器,如Castle
温莎等;壹旦选择了第3方容器,全部的重视解析都会被路由到该第2方容器上。

最基础的器皿

在上头的构想中,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时使用索引找到落成项目并创建实例。
其一实现很轻松,可是有众多标题,例如

  • 1个服务类型不能够对应七个完结项目
  • 从没对实例举办生命周期管理
  • 未曾兑现构造函数注入

最基础的器皿

在地方的构想中,Container类有三个函数,2个是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时行使索引找到完成项目并创办实例。
什么编写三个简便的重视性注入容器,正视注入。那个达成很简短,然而有这么些标题,例如

  • 一个服务类型不可能对应多少个完成项目
  • 从未有过对实例实行生命周期管理
  • 并未有得以达成构造函数注入

针对通用的依赖类型的解析与创建,微软默断定义了4体系型的生命周期,分别如下:

本着通用的依靠类型的分析与创设,微软默料定义了四体系型的生命周期,分别如下:

一字不苟容器的构想 – 类型索引类型

要让2个服务类型对应八个落成项目,可以把TypeMapping改为

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

纵然此外提供1个封存实例的变量,也能兑现生命周期管理,但出示有个别复杂了。
此处能够调换一下思路,把{服务类型=>达成项目}改为{服务类型=>工厂函数},让生命周期的管理在工厂函数中得以完成。

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

突发性我们会想让用户在铺排文件中切换达成项目,那时假使把键类型改成服务类型+字符串,达成起来会轻易多数。
Resolve能够这么用:
Resolve<Service>(serviceKey: Configuration["ImplementationName"])

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

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

要让三个服务类型对应多个落到实处项目,能够把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缓解时应当依据服务类型找到工厂函数,然后实施工厂函数再次来到实例。

品种注册与示范

注重注入类型的登记1般是在先后运行的进口中,如Startup.cs中的ConfigureServices中,该类的主要目的就是挂号重视注入的档次。由于注重注入的显要呈现是接口编制程序,所以本例中,作者以接口和得以达成类的主意来比喻。

先是声美赞臣个接口ITodoRepository和贯彻类TodoRepository一,代码如下:

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贰、TodoRepository3、TodoRepository4等,以便举办出现说法。

然后在Configure瑟维斯s方法内注册接口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中,该类的关键目标正是登记信赖注入的品种。由于注重注入的最首要反映是接口编制程序,所以本例中,小编以接口和促成类的不二等秘书技来比喻。

先是声明一(Wissu)(Karicare)个接口ITodoRepository和得以完成类TodoRepository1,代码如下:

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二、TodoRepository3、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中

接下来经过Get瑟维斯和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个对象肯定不为空,因为如果为空的话,会自动抛异常出来

修正后的容器

那么些容器新扩展了三个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();
        }
    }
}

改革后的器皿仍旧有以下的标题

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

创新后的器皿

其壹容器新添了三个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中,不仅支持地点大家所说的接口类的借助注入,还帮忙普通的档次的重视性注入,比如大家生命三个普通类,示例如下:

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)的技艺能够1二分简单的兑现。

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布局时索要三个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功效域的实例在成立的时候须要先创设效用域,然后在该效率域内再拿走一定的实例,我们看看二个示范并对其开始展览求证。首先,注册正视注入类型,代码如下:

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功效域的实例在创造的时候须求先创制效用域,然后在该功能域内再获得特定的实例,我们看看2个演示并对其张开验证。首先,注册正视注入类型,代码如下:

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

总体代码

容器和示范的全体代码如下

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容器中,针对各样请求,在该请求作用域内保留七个单实例对象是很盛行的,也正是在每一遍请求时期二个类其他对象实例只会创制一回,那样能够大大进步品质。

在ASP.NET第55中学,基于HTTP请求的Scope依赖注入是透过一个ContainerMiddleware来贯彻的,调用该Middleware时,会创制三个限量功用域的DI容器,用于替换当前恳请中已有的默许DI容器。在该管线中,全体继续的Middleware都会使用这么些新的DI容器,在呼吁走完全体Pipeline管线以往,该ContainerMiddleware的作用就甘休了,此时效劳域会被灭绝,并且在该效能域内成立的实例对象也都会销毁释放。

ContainerMiddleware的时序图如下所示:

美高梅开户网址 1

实际的使用情势如下:

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

依照HTTP请求的Scope重视注入

在事先大多盛行的DI容器中,针对种种请求,在该请求功能域内保留二个单实例对象是很盛行的,也正是在每便请求时期二个体系的靶子实例只会创建一遍,那样能够大大升高品质。

在ASP.NET5中,基于HTTP请求的Scope正视注入是透过2个ContainerMiddleware来促成的,调用该Middleware时,会创造1个限制成效域的DI容器,用于替换当前乞请中已某些暗许DI容器。在该管线中,全数继续的Middleware都会选用那些新的DI容器,在伸手走完全部Pipeline管线现在,该ContainerMiddleware的功能就终止了,此时效应域会被灭绝,并且在该功能域内创建的实例对象也都会销毁释放。

ContainerMiddleware的时序图如下所示:

美高梅开户网址 2

切实的选用方法如下:

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

写在最后

本条容器达成了三个依靠注入容器应该某些重轮廓义,可是依然有不少欠缺的地点,例如

  • 不帮忙线程安全
  • 不帮助非泛型的挂号和缓解
  • 不协理只用于钦点范围内的单例
  • 不援救成员注入
  • 不扶助动态代理实现AOP

我在ZKWeb网页框架中也使用了祥和编辑的容器,唯有300多行不过足以知足实际项目标行使。
全部的源代码能够查看那里和这里。

微软从.Net
Core开端提供了DependencyInjection的架空中接力口,那为借助注入提供了2个规范。
在未来也许不会再须要上学Castle 温莎,
Autofac等,而是一贯采纳微软提供的标准接口。
虽说具体的贯彻格局离我们原来越远,可是精通一下它们的法则总是有便宜的。

写在最终

那些容器达成了一个依靠注入容器应该有的根本作用,不过照旧有成都百货上千供不应求的地点,例如

  • 不援助线程安全
  • 不接济非泛型的登记和平消除决
  • 不协助只用于钦命范围内的单例
  • 不扶助成员注入
  • 不协助动态代理达成AOP

我在ZKWeb网页框架中也选取了上下一心编排的容器,唯有300多行可是能够满意实际项目标接纳。
全体的源代码能够翻开那里和这里。

微软从.Net
Core发轫提供了DependencyInjection的悬空中接力口,那为借助注入提供了三个正经。
在未来可能不会再需求学习Castle 温莎,
Autofac等,而是径直利用微软提供的标准接口。
就算现实的贯彻方式离我们原来越远,然则了然一下它们的规律总是有补益的。

普通类的依靠注入处理

当下普通类的借助注入,只协助构造函数,比如我们定于二个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实例

在MVC6中,大家不能够通过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容器帮忙的数额类似作为参数。

采取第二方DI容器

当下,.NETCore不匡助,只可以在全职能版的.NET
framework上技巧运用,所以利用的时候要求小心一下。第1方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
}

这么,你就足以像在此从前1致,使用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上技能运用,所以利用的时候须求留意一下。第1方DI容器的交替经常是在Startup.cs的Configure方法中实行的,在形式的始发处举行替换,以便后续的Middleware会使用相关的依靠注入效用。

首先要引进第二方的容器,以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格局。所以,大家能够通过那种格局,来替换第贰方的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}

诸如此类,你就能够像过去1致,使用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接口,相反,在构造函数里显式增添须求借助的项目就能够,让重视注入引擎本人来分析实例,一旦信赖很难管理的话,就应用抽象工厂。
  3. 依照接口进行编制程序,而不是依照落成实行编制程序。

参考1:
参考2:

同台与推荐

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

一起与引入

本文已协同至目录索引:解读ASP.NET 5 & MVC陆多元

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图