凭借注入,如何编写二个简便的依靠注入容器

乘势周围的品种进一步多,多数类型都引进了注重注入框架,当中最盛行的有Castle
温泽, Autofac和Unity Container。
微软在最新版的Asp.Net
Core中自带了依靠注入的效果,风乐趣能够翻看这里。
关于如何是凭借注入容器网上1度有过多的篇章介绍,那里本身将首要讲述如何落实二个要好的容器,能够扶持你精通注重注入的规律。

乘势大规模的花色更是多,多数档次都引进了借助注入框架,在那之中最流行的有Castle
温莎, Autofac和Unity Container。
微软在风靡版的Asp.Net
Core中自带了依赖注入的效益,有意思味能够翻开那里。
关于怎样是借助注入容器网上早就有广大的稿子介绍,那里本人将根本讲述如何贯彻多个和谐的容器,能够协助您理解重视注入的原理。

在前面的章节(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、SignalCRUISER、Entity
Framrwork等都凭借于依靠注入的IServiceProvider接口,针对该接口微软提交了暗中同意的贯彻ServiceProvider,以及Ninject和AutoFac版本的包装,当然你也足以采用任何第一方的借助注入容器,如Castle
温莎等;1旦选用了第壹方容器,全数的依靠解析都会被路由到该第二方容器上。

在头里版本的信赖性注入功用里,重视注入的输入有MVC中的IControllerFactory和Web
API中的IHttpControllerActivator中,在新版ASP.NET5中,正视注入变成了最尾部的功底支撑,MVC、Routing、SignalCR-V、Entity
Framrwork等都凭借于依靠注入的IServiceProvider接口,针对该接口微软提交了默许的贯彻ServiceProvider,以及Ninject和AutoFac版本的包裹,当然你也得以选拔任何第三方的正视性注入容器,如Castle
温泽等;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在里头成立了3个服务类型(接口类型)到落到实处项指标目录,Resolve时使用索引找到达成项目并创办实例。
这几个达成相当粗略,可是有广大主题素材,例如

  • 2个服务类型不可能对应八个落实项目
  • 尚未对实例进行生命周期管理
  • 尚无达成构造函数注入

最基础的容器

在上头的构想中,Container类有八个函数,1个是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时行使索引找到达成项目并创办实例。
那么些完成很轻易,不过有这一个标题,例如

  • 多个服务类型不能够对应多少个落实项目
  • 未曾对实例实行生命周期管理
  • 从不兑现构造函数注入

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

本着通用的重视类型的解析与创立,微软默断定义了四种类型的生命周期,分别如下:

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

要让七个服务类型对应多少个落到实处项目,能够把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; }

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

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

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

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

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和促成类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;    }}

为了演示分裂的扬言周期类型,提议多落成多少个类,比如TodoRepository2、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;  //这里就可以使用该对象了    }}

脾气注入,则是透过在性质上加2个[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般是在先后运行的输入中,如Startup.cs中的ConfigureServices中,该类的最主要指标就是注册信赖注入的项目。由于信赖注入的严重性呈现是接口编制程序,所以本例中,笔者以接口和兑现类的艺术来比喻。

率先声Bellamy(Bellamy)个接口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、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实例的格局当下有如下二种(但范围不1):

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

勘误后的器皿

这些容器新增添了2个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();
        }
    }
}

改进后的器皿仍旧有以下的难题

  • 尚无对实例举行生命周期管理
  • 从没完结构造函数注入

革新后的器皿

其一容器新扩充了三个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.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)的力量能够卓殊轻便的兑现。

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布局时索要贰个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成效域的实例在创立的时候供给先成立效率域,然后在该成效域内再拿走一定的实例,大家看看四个示范并对其展开认证。首先,注册依赖注入类型,代码如下:

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

完整代码

容器和演示的欧洲经济共同体代码如下

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.NET5中,基于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容器中,针对每一个请求,在该请求功效域内保留三个单实例对象是相当的火的,也正是在每一趟请求期间一个类别的目的实例只会成立1回,那样能够大大进步质量。

在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));

写在最后

那几个容器完成了3个正视注入容器应该有的根本功效,然而依然有数不清供不应求的地点,例如

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

我在ZKWeb网页框架中也选择了友好编写的器皿,唯有300多行可是能够满意实际项指标选择。
全部的源代码能够翻开这里和这里。

亚洲必赢官网,微软从.Net
Core初阶提供了DependencyInjection的架空切口,那为借助注入提供了1个规范。
在将来只怕不会再供给上学Castle 温泽,
Autofac等,而是一直使用微软提供的标准接口。
尽管如此实际的落到实处方式离咱们原来越远,不过理解一下它们的法则总是有实益的。

写在终极

其1容器达成了七个借助注入容器应该有些重大功能,但是依旧有许多相差的地点,例如

  • 不援救线程安全
  • 不补助非泛型的注册和消除
  • 不支持只用于指定范围内的单例
  • 不帮忙成员注入
  • 不帮助动态代理实现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实例

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

平凡类中取得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方法。所以,我们得以经过那种艺术,来替换第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集成的案例:

运用第二方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);//将现有的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方法。所以,大家可以透过那种艺术,来替换第3方的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();
    }
}

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

一流施行

在应用正视注入的的时候,我们相应遵循如下最棒实施。

  1. 做别的工作之前,务必在先后入口点提前注册全部的注重类型。
  2. 制止直接动用IServiceProvider接口,相反,在构造函数里显式加多需求依靠的类型就能够,让依赖注入引擎本人来分析实例,1旦重视很难管理的话,就利用抽象工厂。
  3. 据他们说接口举行编制程序,而不是根据完毕举行编制程序。

参考1:
参考2:

一级实施

在运用重视注入的的时候,大家相应遵循如下最棒施行。

  1. 做别的交事务情在此以前,务必在程序入口点提前注册全数的信赖类型。
  2. 防止直接利用IServiceProvider接口,相反,在构造函数里显式增多要求依赖的项目就可以,让重视注入引擎本身来分析实例,1旦重视很难管理的话,就动用抽象工厂。
  3. 据说接口举行编制程序,而不是基于实现举行编制程序。

参考1:
参考2:

联手与引入

本文已协同至目录索引:解读ASP.NET 伍 & MVC陆种类

共同与推荐

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

网站地图xml地图