.NET Core依赖注入与Autofac注入介绍
本文不介绍IoC和DI的概念，如果你对Ioc之前没有了解的话，建议先去搜索一下相关的资料
（.net core 3.0已经不需要这种做法了）
这篇文章将简单介绍一下AutoFac的基本使用以及在asp .net core中的应用
Autofac介绍
组件的三种注册方式
反射
现成的实例(new)
lambda表达式 (一个执行实例化对象的匿名方法)
下面是一些简短的示例，我尽可能多的列出来一些常用的注册方式，同时在注释中解释下“组件”、“服务”等一些名词的含义
// 创建注册组件的builder
var builder = new ContainerBuilder();
//根据类型注册组件 ConsoleLogger 暴漏服务：ILogger
builder.RegisterType().As();
//根据类型注册组件 ConsoleLogger,暴漏其实现的所有服务（接口）
builder.RegisterType().AsImplementedInterfaces();
// 根据实例注册组件 output 暴漏服务：TextWriter
var output = new StringWriter();
builder.RegisterInstance(output).As();
//表达式注册组件，这里我们是在构造函数时传参->“musection” 暴漏服务：IConfigReader
builder.Register(c =new ConfigReader(“mysection”)).As();
//表达式注册组件,解析时传参
var service = scope.Resolve(
new NamedParameter(“section”, “mysection”));
//反射注册组件，直接注册了ConsoleLogger类（必须是具体的类），如果ConsoleLogger有多个构造函数，将会取参数最多的那个构造函数进行实例化
builder.RegisterType();
//反射注册组件，手动指定构造函数，这里指定了调用 MyComponent（ILogger log,IConfigReader config）的构造函数进行注册
builder.RegisterType()
.UsingConstructor(typeof(ILogger), typeof(IConfigReader));
//注册MySingleton类中的静态变量"Instance"，ExternallyOwned()函数指定自己控制实例的生命周期，而不是由autofac自动释放
builder.RegisterInstance(MySingleton.Instance).ExternallyOwned();
//一个组件暴漏两个服务
builder.RegisterType().As().As();
//注册当前程序集中以“Service”结尾的类
builder.RegisterAssemblyTypes(System.Reflection.Assembly.GetExecutingAssembly()).Where(t => t.Name.EndsWith(“Service”)).AsImplementedInterfaces();
//注册"MyApp.Repository"程序集中所有的类
builder.RegisterAssemblyTypes(GetAssembly(“MyApp.Repository”)).AsImplementedInterfaces();
//构建一个容器完成注册
var rootcontainer = builder.Build();
//可以通过下面这种方式手动获取IConfigReader 的实现类
//这种手动解析的方式需要 从生命周期作用域内获取组件,以保证组件最终被释放
//不要直接从根容器rootcontainer中解析组件，很有可能会导致内存泄漏
using(var scope = rootcontainer.BeginLifetimeScope())
{
var reader = scope.Resolve();
}
如果不止一个组件暴露了相同的服务, Autofac将使用最后注册的组件作为服务的提供方。 想要覆盖这种行为, 在注册代码后使用 PreserveExistingDefaults() 方法修改
生命周期
using(var scope = rootcontainer.BeginLifetimeScope())
上面的这段代码创建了一个生命周期作用域
生命周期作用域是可释放的，在作用域内解析的组件一定要保证在using之内使用或者最后手动调用组件的Dispose()函数
避免引用类的生命周期大于被引用类的生命周期 ：如service 引用 repository 如果service的生命周期为单例，repository的生命周期为perrequest。service不会释放，所以最终会造成相关的repository始终无法释放的情况（Captive Dependencies）
虽然我们需要尽可能的避免直接从根容器解析组件，但总有例外的情况，对于非单例的组件，一定不要忘记调用组件的Dispose函数，实际上对于非单例的组件，从项目架构上来说，理论上应该是从构造函数注入进去的而不是手动解析。 需要手动解析的应该为一些配置帮助类等
对于一个具体组件（类）的生命周期分为以下几种（后面的函数是autofac对应的函数）：
每个依赖一个实例(Instance Per Dependency) (默认) ----InstancePerDependency()
单一实例(Single Instance) 单例 ----SingleInstance()
每个生命周期作用域一个实例(Instance Per Lifetime Scope)----InstancePerLifetimeScope()
每个匹配的生命周期作用域一个实例(Instance Per Matching Lifetime Scope)----InstancePerMatchingLifetimeScope()
每个请求一个实例(Instance Per Request) asp.net web请求----InstancePerRequest()
每次被拥有一个实例(Instance Per Owned) ----InstancePerOwned()
如果你以前在传统的ASP.NET MVC项目中用过autofac，需要注意一些区别：
.net Core中需要使用InstancePerLifetimeScope替代之前(传统asp.net)的InstancePerRequest，保证每次HTTP请求只有唯一的依赖实例被创建。InstancePerRequest请求级别已经不存在了
.net Core中Web Api与Mvc的注册方式一样
.net Core中不再需要注册控制器,控制器由.net core创建，不归autofac管理（除了控制器的构造函数），这也解释了为什么不再使用InstancePerRequest生命周期,但是可以通过AddControllersAsServices()函数改变，想要深入了解的可以查看：https://www.strathweb.com/2016/03/the-subtle-perils-of-controller-dependency-injection-in-asp-net-core-mvc/
AutoFac 在asp .net core中的使用
在.net core 中使用autofac还是比较简单的，相比于传统的asp.net web 项目，省去了很多步骤
引入nuget程序包：
Autofac
Autofac.Extensions.DependencyInjection
startup 中代码：
public static IContainer AutofacContainer;
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
//注册服务进 IServiceCollection
services.AddMvc();
ContainerBuilder builder = new ContainerBuilder();
//将services中的服务填充到Autofac中.
builder.Populate(services);
//新模块组件注册
builder.RegisterModule<DefaultModuleRegister>();
//创建容器.
AutofacContainer = builder.Build();
//使用容器创建 AutofacServiceProvider
return new AutofacServiceProvider(AutofacContainer);
}
上面代码调用了builder的RegisterModule函数,这个函数需要传入一个TModule的泛型，称之为autofac的模块
模块的功能就是把所有相关的注册配置都放在一个类中，使代码更易于维护和配置，下面展示了DefaultModuleRegister中的代码
DefaultModuleRegister：
public class DefaultModuleRegister : Module
{
protected override void Load(ContainerBuilder builder)
{
//注册当前程序集中以“Ser”结尾的类,暴漏类实现的所有接口，生命周期为PerLifetimeScope
builder.RegisterAssemblyTypes(System.Reflection.Assembly.GetExecutingAssembly()).Where(t => t.Name.EndsWith(“Ser”)).AsImplementedInterfaces().InstancePerLifetimeScope();
builder.RegisterAssemblyTypes(System.Reflection.Assembly.GetExecutingAssembly()).Where(t => t.Name.EndsWith(“Repository”)).AsImplementedInterfaces().InstancePerLifetimeScope();
//注册所有"MyApp.Repository"程序集中的类
//builder.RegisterAssemblyTypes(GetAssembly(“MyApp.Repository”)).AsImplementedInterfaces();
}
public static Assembly GetAssembly(string assemblyName)
{
var assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(AppContext.BaseDirectory + $"{assemblyName}.dll");
return assembly;
}
}
Configure函数中可以选择性的加上程序停止时Autofac的释放函数：
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IApplicationLifetime appLifetime)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
//程序停止调用函数
appLifetime.ApplicationStopped.Register(() => { AutofacContainer.Dispose(); });
}
Controller中代码：
private IUserSer _user;
private IUserSer _user2;
public HomeController(IUserSer user, IUserSer user2)
{
_user = user;
_user2 = user2;
}
public IActionResult Index()
{
using (var scope = Startup.AutofacContainer.BeginLifetimeScope())
{
IConfiguration config = scope.Resolve<IConfiguration>();
IHostingEnvironment env = scope.Resolve<IHostingEnvironment>();
}
string name = _user.GetName();
string name2 = _user2.GetName();
return View();
}
可以看到，因为我们将IServiceCollection中的服务填充到了autofac中了，所以现在可以在任何位置通过AutoFac解析出来.net core默认注入的服务（IConfiguration,IHostingEnvironment等）了
正常项目使用中，我们应该将AutofacContainer放在一个公共的类库中以便各个工程均可调用
0 前言
本文主要介绍了ASP.NET Core自带的依赖注入框架的用法，然后针对原生框架的不足，介绍了更加完备的autofac框架的集成和使用。
1 .NET Core原生DI框架
.Net Core自带一个依赖注入的框架，使用起来很是方便，不多说，先从简单示例做起。
1.1 简单示例
以ASP.NET Core web的API项目为例：
首先，定义接口IPay和实现类WxPay:
public interface IPay
{
void Pay();
}
public void Pay()
{
Console.WriteLine("wxpay");
}
然后在Startup类中的ConfigureService方法中进行注册：
services.AddScoped<IPay, WxPay>();
接着，就可以在Contoller中使用构造函数注入：
[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
private readonly IPay pay;
public WeatherForecastController(IPay pay)
{
this.pay = pay;
}
[HttpGet]
public string Get()
{
return pay.Pay();
}
}
最后，启动程序，看到输出：
wxpay
1.2 生存周期
* Singleton: 单例模式，即在整个应用程序生存期内只会有一个实例
* Scoped：作用域对象在一个客户端请求中是相同的，但在多个客户端请求中是不同的
* Transient：暂时性对象始终不同，无论是不是同一个请求（同一个请求里的不同服务）同一个客户端，每次都是创建新的实例
对Transient的模式，我个人还没怎么理解，暂时先放在这里。
按我个人的想法，正常情况下使用Scoped模式，保证在当前请求内保证一致即可。而Transient模式的场景感觉就是在同一个请求中，获取服务后进行业务操作时，获取相关服务的数据状态发生了变更，因此在再次使用时，需要重新获取服务状态，因此使用暂时模式。
这个可以参见一下几个理解：
另外，看官方文档上的示例：MSDN
1.3 同一接口多个实现
对于IPay接口来说，除了WxPay我们还有AliPay的支付方式，
public string Pay()
{
return "AliPay";
}
此时在DI注入时就需要将两个都注入：
services.AddScoped<IPay, WxPay>();
services.AddScoped<IPay, AliPay>();
然后我们再运行代码，会发现页面此时的输入变成了：AliPay。 说明这种情况下注入的是最后一次的接口实现。
那么如何获取到其他的实现呢？
我们可以通过注入IEnumerable<IPay>来实现。
[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
private readonly IPay pay;
private readonly IEnumerable<IPay> payList;
public WeatherForecastController(IPay pay, IEnumerable<IPay> payList)
{
this.pay = pay;
this.payList = payList;
}
[HttpGet]
public string Get()
{
var sb = new StringBuilder();
foreach (var pay in payList)
{
sb.AppendLine(pay.Pay());
}
return sb.ToString();
}
}
此时，运行后得到的输出是：
wxpay
AliPay
这样根据注入payList的类型就能得到所对应的服务实现。当然也可以使用一个工厂类将所有实现注入，然后通过服务类型的方式进行获取。
不过，更推荐使用下面要介绍的Autofac来命名实现。
2 Autofac
Autofac是.net语言的老牌依赖注入框架了，详细的见其官网，我们只管拿来用就完事了。
2.1 简单配置
- 安装autofac
这个不多说了，在Nuget Packge管理界面查找安装即可。
- Program.cs启动配置
需要在CreateHostBuilder中对autofac进行配置，使用UseServiceProviderFactory(new AutofacServiceProviderFactory())， 将服务提供程序注入到.net core中：
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.UseServiceProviderFactory(new AutofacServiceProviderFactory())
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>();
});
- 在Startup类中进行接口注入
为了代码结构的阅读方便，我们使用一个单独的注入类DependencyRegister，在类中实现对接口的注入：
public static class DependencyRegister
{
public static ContainerBuilder Register(ContainerBuilder builder)
{
builder.RegisterType<MyService>().As<IMyInterface>();
return builder;
}
}
注入容器我们需要添加ConfigureContainer方法，然后在Startup.cs中添加：
public void ConfigureContainer(ContainerBuilder builder)
{
DependencyRegister.Register(builder);
}
至此，MyService作为IMyInterface的实现就在容器中，在controller类中通过像.net core中一样的构造注入方式就能得到对应的实例。
2.2 命名：同一接口多个实现
还是以上面的IPay为例，我们在DependencyRegister的Register()中添加：
builder.RegisterType<WxPay>().Named<IPay>(typeof(WxPay).Name);
builder.RegisterType<AliPay>().Named<IPay>(typeof(AliPay).Name);
上面表示往容器中分别注册了两个名为"WxPay","AliPay"的IPay接口实现。
autofac可以通过注入IComponentContext来获取上下文，然后从上下文中通过名称来获取对应的接口实现。
如我们新增一个homeController，代码如下：
[ApiController]
[Route("home")]
public class HomeController : ControllerBase
{
private readonly IPay wxPay;
private readonly IPay aliPay;
public HomeController(IComponentContext componentContext)
{
builder.RegisterType<WxPay>().Named<IPay>(typeof(WxPay).Name);
builder.RegisterType<AliPay>().Named<IPay>(typeof(AliPay).Name);
}
[Route("test")]
[HttpGet]
public string Test()
{
var str = new StringBuilder();
str.AppendLine(wxPay.Pay());
str.AppendLine(aliPay.Pay());
return str.ToString();
}
}
运行代码，访问/home/test,同样能见到两个接口的输出。
2.3 按条件批量注入
日常开发中，新增接口和实现是很多的，如果每次新增都需要手动添加的话是比较繁琐的。于是我们可以用通过通配符的方式来实现自动批量注入，如下面查询以Pay为结尾的类：
var assembly1 = Assembly.GetExecutingAssembly();
builder.RegisterAssemblyTypes(assembly1)
.PublicOnly()
.Where(r => r.Name.EndsWith("Pay"))
.AsImplementedInterfaces();
