借助注入,怎样编写二个简练的借助注入容器

By admin in 4858.com on 2019年4月4日

借助注入,怎样编写二个简练的借助注入容器。乘胜大面积的档次愈多,许多项目都引入了依靠注入框架,在那之中最盛行的有Castle
温泽, Autofac和Unity Container。
微软在风行版的Asp.Net
Core中自带了借助注入的作用,有趣味能够查看那里。
至于怎么样是依靠注入容器网寒本草切要有成都百货上千的作品介绍,那里笔者将重点讲述如何兑现一个祥和的容器,能够扶助您知道依赖注入的规律。

乘机相近的类别更是多,许7类别都引入了借助注入框架,在那之中最风靡的有Castle
温泽, Autofac和Unity Container。
微软在风行版的Asp.Net
Core中自带了依靠注入的法力,有趣味能够查阅那里。
关于怎么样是凭借注入容器网上一度有众多的篇章介绍,那里本人将第3讲述如何实现三个要好的容器,能够扶助你驾驭依赖注入的法则。

在前方的章节(Middleware章节)中,我们关系了借助注入作用(Dependency
Injection),ASP.NET
伍正式将依靠注入实行了全职能的落到实处,以便开发职员能够开发更具弹性的机件程序,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、SignalLX570、Entity
Framrwork等都凭借于依靠注入的IServiceProvider接口,针对该接口微软提交了默许的兑现ServiceProvider,以及Ninject和AutoFac版本的包装,当然你也得以应用别的第2方的依赖性注入容器,如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时使用索引找到完成项目并创制实例。
以此达成很简短,不过有好多难点,例如

  • 1个服务类型不能够对应三个落到实处项目
  • 尚未对实例进行生命周期管理
  • 尚无落到实处构造函数注入

最基础的容器

在上面包车型大巴构想中,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在里头成立了1个服务类型(接口类型)到落实项目的目录,Resolve时接纳索引找到完结项目并创立实例。
其1完毕很简短,不过有无数难点,例如

  • 四个服务类型不可能对应八个完成项目
  • 未有对实例进行生命周期管理
  • 不曾落到实处构造函数注入

本着通用的依靠类型的分析与创造,微软暗许定义了四连串型的生命周期,分别如下:

针对通用的依靠类型的分析与创立,微软暗中同意定义了四种档次的生命周期,分别如下:

精雕细刻容器的构想 – 类型索引类型

要让叁个服务类型对应多个完毕项目,能够把TypeMapping改为

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

比方其余提供3个封存实例的变量,也能落到实处生命周期管理,但出示有些复杂了。
此处能够变换一下思路,把{服务类型=>达成项目}改为{服务类型=>工厂函数},让生命周期的治本在工厂函数中实现。

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

只要其它提供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; }
类型 描述
Instance 任何时间都只能使用特定的实例对象,开发人员需要负责该对象的初始化工作。
Transient 每次都重新创建一个实例。
Singleton 创建一个单例,以后每次调用的时候都返回该单例对象。
Scoped 在当前作用域内,不管调用多少次,都是一个实例,换了作用域就会再次创建实例,类似于特定作用内的单例。
类型 描述
Instance 任何时间都只能使用特定的实例对象,开发人员需要负责该对象的初始化工作。
Transient 每次都重新创建一个实例。
Singleton 创建一个单例,以后每次调用的时候都返回该单例对象。
Scoped 在当前作用域内,不管调用多少次,都是一个实例,换了作用域就会再次创建实例,类似于特定作用内的单例。

改正容器的构想 – Register和Resolve的处理

在规定了索引类型后,RegisterResolve的拍卖都应当跟着更改。
Register注册时应当率先根据兑现项目变更工厂函数,再把工厂函数加到服务类型对应的列表中。
Resolve杀鸡取蛋时应有依据服务类型找到工厂函数,然后实施工厂函数重回实例。

改进容器的构想 – Register和Resolve的处理

在明确了索引类型后,RegisterResolve的处理都应当跟着变动。
Register登记时应当首先依照兑现项目变更工厂函数,再把工厂函数加到服务类型对应的列表中。
Resolve消除时应有依据服务类型找到工厂函数,然后实施工厂函数重回实例。

花色注册与示范

借助注入类型的登记一般是在程序运维的进口中,如Startup.cs中的ConfigureServices中,该类的首要目标正是登记注重注入的类型。由于信赖注入的主要反映是接口编制程序,所以本例中,笔者以接口和落实类的方式来比喻。

先是声澳优个接口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;    }}

为了演示区别的宣示周期类型,提议多落成多少个类,比如TodoRepository2、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中

接下来经过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中的Configure瑟维斯s中,该类的根本指标正是挂号依赖注入的档次。由于依赖注入的首要性浮现是接口编制程序,所以本例中,笔者以接口和贯彻类的点子来比喻。

第壹声多美滋个接口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二、TodoRepository三、TodoRepository4等,以便进行出现说法。

然后在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个对象肯定不为空,因为如果为空的话,会自动抛异常出来

一字不苟后的容器

其1容器新增了八个ResolveMany函数,用于缓解七个实例。
除此以外还用了Expression.Lambda4858.com,编写翻译工厂函数,生功用率会比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();
        }
    }
}

改正后的器皿还是有以下的难题

  • 从不对实例举办生命周期管理
  • 从未有过达成构造函数注入

革新后的容器

以此容器新增了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();
        }
    }
}

一字不苟后的器皿依旧有以下的标题

  • 平素不对实例进行生命周期管理
  • 没有落到实处构造函数注入

普通类的注重性注入

在新版的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.NET第55中学,不仅支持地方大家所说的接口类的正视注入,还扶助普通的档次的信赖注入,比如大家生命一个普通类,示例如下:

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)的力量可以11分简单的贯彻。

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协会时须要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,那样做的裨益是流入的实例不自然必要是单例。
用表明式营造的工厂函数消除的时候的质量会很高。

兑现构造函数注入

以上边代码为例

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

完整代码

容器和演示的全部代码如下

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容器中,针对每种请求,在该请求功用域内保留2个单实例对象是很盛行的,也正是在历次请求时期八个连串的对象实例只会创造一遍,那样能够大大进步品质。

在ASP.NET5中,基于HTTP请求的Scope正视注入是经过二个ContainerMiddleware来促成的,调用该Middleware时,会创设3个限量功用域的DI容器,用于替换当前呼吁中已有的私下认可DI容器。在该管线中,全部继续的Middleware都会动用这些新的DI容器,在呼吁走完全体Pipeline管线以往,该ContainerMiddleware的效果就与世长辞了,此时功效域会被灭绝,并且在该成效域内创造的实例对象也都会销毁释放。

ContainerMiddleware的时序图如下所示:

4858.com 1

具体的选用方法如下:

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

依照HTTP请求的Scope依赖注入

在头里很多风行的DI容器中,针对各类请求,在该请求功用域内保留二个单实例对象是很盛行的,约等于在每一趟请求时期贰个种类的靶子实例只会创制壹回,那样能够大大升高质量。

在ASP.NET5中,基于HTTP请求的Scope信赖注入是经过一个ContainerMiddleware来兑现的,调用该Middleware时,会创立叁个限制效率域的DI容器,用于替换当前恳请中已某些暗中同意DI容器。在该管线中,全体继续的Middleware都会接纳那么些新的DI容器,在乞请走完全数Pipeline管线今后,该ContainerMiddleware的效果就得了了,此时效用域会被灭绝,并且在该功效域内创建的实例对象也都会销毁释放。

ContainerMiddleware的时序图如下所示:

4858.com 2

实际的采纳办法如下:

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

写在最终

本条容器达成了3个依靠注入容器应该有个别重大作用,可是照旧有成都百货上千欠缺的地点,例如

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

我在ZKWeb网页框架中也运用了自个儿编写的器皿,只有300多行不过足以知足实际项指标行使。
完整的源代码能够查看那里和这里。

微软从.Net
Core早先提供了DependencyInjection的肤浅接口,那为借助注入提供了四个标准。
在今后说不定不会再需求上学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实例

在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容器帮忙的数额类似作为参数。

选用第贰方DI容器

当前,.NETCore不协助,只辛亏全职能版的.NET
framework上才能运用,所以利用的时候供给留意一下。第一方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中挪到该表明式内,不然会报分外,等待微软化解。

其它,还有3个措施,微软脚下的实例项目中还尚无精通,通过分析部分代码,我们得以窥见,在Microsoft.AspNet.Hosting程序中的StartupLoader.cs肩负程序入口点的施行,在该文件中,我们领略首先是调用Startup.cs中的ConfigureServices办法,然后再调用Configure措施;我们得以看出示例中的ConfigureServices的重回值是void类型的,但在源码分析中发觉,在依照预订解析ConfigureServices措施的时候,其首先判断有未有重临类型是IServiceProvider的,即便有则执行该措施,用利用该再次回到中回到的新IServiceProvider实例;未有的话,再持续搜寻void类型的ConfigureServices方法。所以,大家能够通过那种格局,来替换第3方的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集成的案例:

利用第叁方DI容器

方今,.NETCore不支持,只还好兼职能版的.NET
framework上才能动用,所以使用的时候须要留意一下。第二方DI容器的交替常常是在Startup.cs的Configure方法中举办的,在措施的启幕处实行替换,以便后续的Middleware会使用相关的借助注入作用。

首先要引入第3方的容器,以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中挪到该表达式内,不然会报格外,等待微软化解。

其它,还有3个办法,微软脚下的实例项目中还尚无当面,通过分析部分代码,我们得以窥见,在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);  //将现有的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. 幸免直接利用I瑟维斯Provider接口,相反,在构造函数里显式添加需求借助的品类即可,让信赖注入引擎本身来分析实例,壹旦正视很难管理以来,就动用抽象工厂。
  3. 据说接口实行编程,而不是依据达成举行编制程序。

参考1:
参考2:

极品实践

在选取正视注入的的时候,大家应有听从如下最棒实践。

  1. 做别的业务在此之前,务必在程序入口点提前注册全部的正视性类型。
  2. 防止直接运用IServiceProvider接口,相反,在构造函数里显式添加需求依靠的门类即可,让注重注入引擎本身来分析实例,一旦注重很难管理以来,就接纳抽象工厂。
  3. 基于接口实行编制程序,而不是依照完毕进行编制程序。

参考1:
参考2:

手拉手与推介

正文已1起至目录索引:解读ASP.NET 五 & MVC陆文山会海

1同与引进

正文已协同至目录索引:解读ASP.NET 5 &
MVC6系列

发表评论

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

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有