在AspNetCore3.0中使用Autofac
1. 引入Nuget包
Autofac
Autofac.Extensions.DependencyInjection
2. 修改Program.cs
将默认ServiceProviderFactory指定为AutofacServiceProviderFactory
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>();
})
.UseServiceProviderFactory(new AutofacServiceProviderFactory());
3. 修改Startup.cs
添加方法 ConfigureContainer
public void ConfigureContainer(ContainerBuilder builder)
{
// 在这里添加服务注册
builder.RegisterType<TopicService>();
}
4. 配置Controller全部由Autofac创建
默认情况下，Controller的参数会由容器创建，但Controller的创建是有AspNetCore框架实现的。要通过容器创建Controller，需要在Startup中配置一下：
services.Replace(
ServiceDescriptor
.Transient<IControllerActivator, ServiceBasedControllerActivator>()
);
// 或者将Controller加入到Services中，这样写上面的代码就可以省略了
services.AddControllersWithViews().AddControllersAsServices();
如果需要在Controller中使用属性注入，需要在ConfigureContainer中添加如下代码
var controllerBaseType = typeof(ControllerBase);
builder.RegisterAssemblyTypes(typeof(Program).Assembly)
.Where(t => controllerBaseType.IsAssignableFrom(t) && t != controllerBaseType)
.PropertiesAutowired();
5. 在Controller中使用
[Route("api/[controller]")]
[ApiController]
public class TestController : ControllerBase
{
private readonly TopicService _service;
private readonly IServiceProvider _provider;
public TopicService Service { get; set; }
public TestController(TopicService service, IServiceProvider provider)
{
_service = service;
_provider = provider;
}
[HttpGet("{id}")]
public async Task<Result> GetTopics(int id)
{
// 构造函数注入
return await _service.LoadWithPosts(id);
}
[HttpGet("Get/{id}")]
public async Task<Result> GetTopics2(int id)
{
// 属性注入
return await Service.LoadWithPosts(id);
}
}
6. 使用拦截器
添加Nuget包：Autofac.Extras.DynamicProxy
一、定义一个拦截器类，实现IInterceptor
public class TestInterceptor : IInterceptor
{
public void Intercept(IInvocation invocation)
{
Console.WriteLine("你正在调用方法 \"{0}\" 参数是 {1}... ",
invocation.Method.Name,
string.Join(", ", invocation.Arguments.Select(a => (a ?? "").ToString()).ToArray()));
invocation.Proceed();
Console.WriteLine("方法执行完毕，返回结果：{0}", invocation.ReturnValue);
}
}
二、修改Startup的ConfigureContainer方法
注意：
1、拦截器注册要在使用拦截器的接口和类型之前
2、在类型中使用，仅virtual方法可以触发拦截器
builder.RegisterType<TestInterceptor>(); // 要先注册拦截器
builder.RegisterAssemblyTypes(typeof(Program).Assembly)
.AsImplementedInterfaces()
.EnableInterfaceInterceptors();
var controllerBaseType = typeof(ControllerBase);
builder.RegisterAssemblyTypes(typeof(Program).Assembly)
.Where(t => controllerBaseType.IsAssignableFrom(t) && t != controllerBaseType)
.PropertiesAutowired() // 允许属性注入
.EnableClassInterceptors(); // 允许在Controller类上使用拦截器
三、在需要使用拦截器的类或接口上添加描述
[Intercept(typeof(TestInterceptor))]
四、Sample
在接口上添加拦截器，当调用接口的方法时，都会进入拦截器
public class LogUtil : ILogUtil
{
public void Show(string message)
{
Console.WriteLine(message);
}
}
[Intercept(typeof(TestInterceptor))]
public interface ILogUtil
{
void Show(string message);
}
在Controller上使用拦截器
[Intercept(typeof(TestInterceptor))]
[Route("api/[controller]")]
[ApiController]
public class TestController : ControllerBase
{
private readonly TopicService _service;
private readonly IServiceProvider _provider;
private readonly ILogUtil _log;
public TopicService Service { get; set; }
public TestController(TopicService service, IServiceProvider provider, ILogUtil log)
{
_service = service;
_provider = provider;
_log = log;
}
// 会触发拦截器
[HttpGet("{id}")]
public virtual async Task<Result> GetTopics(int id)
{
// 构造函数注入
return await _service.LoadWithPosts(id);
}
// 不会触发拦截器
[HttpGet("Get/{id}")]
public async Task<Result> GetTopics2(int id)
{
return await Service.LoadWithPosts(id);
}
// 会由_log触发拦截器
[HttpGet("Get2")]
public string GetTopics3()
{
_log.Show("abc");
return "Hello World";
}
// 会触发拦截器2次
[HttpGet("Get2")]
public virtual string GetTopics4()
{
_log.Show("abc");
return "Hello World";
}
}
7. 一个接口多个实现
// 1、需要指定键值 是一个Object类型
// 2、注册服务使用方法Keyed 参数为指定的键值中的值 （每一个服务的实现和键值要一一对应起来，这里不能重复）
// 3、获取服务： 直接通过ResolveKeyed() 获取服务无，方法需要传入 指定对应的键值
// 先获取一个IIndex，再通过IInex 索引来获取服务的实例
containerBuilder.RegisterType<TestServiceD>().Keyed<ITestServiceD>(DeviceState.TestServiceD);
containerBuilder.RegisterType<TestServiceD_One>().Keyed<ITestServiceD>(DeviceState.TestServiceD_One);
containerBuilder.RegisterType<TestServiceD_Two>().Keyed<ITestServiceD>(DeviceState.TestServiceD_Two);
containerBuilder.RegisterType<TestServiceD_Three>().Keyed<ITestServiceD>(DeviceState.TestServiceD_Three);
// 为不同的实现指定名称，这个比较简单，推荐
containerBuilder.RegisterType<TestServiceD_Three>().Named<ITestServiceD>("three");
IContainer container = containerBuilder.Build();
IIndex<DeviceState, ITestServiceD> index = container.Resolve<IIndex<DeviceState, ITestServiceD>>();
ITestServiceD testServiceD= index[DeviceState.TestServiceD];
ITestServiceD TestServiceD_One = index[DeviceState.TestServiceD_One];
ITestServiceD TestServiceD_Two = index[DeviceState.TestServiceD_Two];
ITestServiceD TestServiceD_Three = index[DeviceState.TestServiceD_Three];
// 根据名称解析
var t2 = container.ResolveNamed<ITestServiceD>("three");
Console.WriteLine("abc");
上面的做法在客户端或者之前的MVC项目中可以这样用。但在AspNetCore3.0中，我们似乎根本拿不到IContainer，所以不能手动Resolve指定的实现（请看下方的补充），下面是我自己摸索的办法：
public interface ITestUtil
{
void Show(string content);
}
public class TestUtil1 : ITestUtil
{
public void Show(string content)
{
Console.WriteLine("TestUtil1：" + content);
}
}
public class TestUtil2 : ITestUtil
{
public void Show(string content)
{
Console.WriteLine($"TestUtil2：{content}");
}
}
别忘了在Startup中注册服务
builder.RegisterType<TestUtil1>().As<ITestUtil>();
builder.RegisterType<TestUtil2>().As<ITestUtil>();
// 或者这样做，如果程序级中的类型实现了某个接口，
// 会自动把该类型注册为接口的实现，
// 这个方法比较狠，个人感觉还是慎用的好
builder.RegisterAssemblyTypes(this.GetType().Assembly)
.AsImplementedInterfaces()
.PropertiesAutowired();
// 默认情况下，构造函数注入和属性注入的结果都是最后注册的那个实现,
// 也就是TestUtil2
private readonly ITestUtil _util;
public HomeController(ITestUtil util, IServiceProvider provider)
{
_util = util;
// 如果知道注册的顺序，可以用这种方式，
// 第一个注册是TestUtil1，所以这里返回TestUtil1
var util1 = provider.GetServices<ITestUtil>().ElementAtOrDefault(0);
util1?.Show("指定注册为ITestUtil的第一个实现");
// 一般情况下用这种方式，指定成具体的类型 TestUtil1
var utilFirst = provider.GetServices<ITestUtil>()
.SingleOrDefault(t => t.GetType() == typeof(TestUtil1));
util1?.Show("指定名称为TestUtil的实现");
}
补充：获取容器 IContainer
下面是官方推荐的方式，定义一个继承自Autofac.Module的类，重写其Load方法，将Startup.cs中ConfigurationContainer方法中的代码全部移至Load的方法内，
请注意该 RmesAutoFacModule 类中定义了一个静态字段 _container，用于接收注册完成后的Container容器。
在 Load 方法的最后一行，builder将容器传出，我们使用 _container 接收到，后面就可以直接使用 RmesAutoFacModule.GetContainer() 获取容器了。
public class RmesAutoFacModule : Module
{
private static IContainer _container;
protected override void Load(ContainerBuilder builder)
{
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
.AsImplementedInterfaces()
.EnableInterfaceInterceptors();
var controllerBaseType = typeof(ControllerBase);
builder.RegisterAssemblyTypes(typeof(Program).Assembly)
.Where(t => controllerBaseType.IsAssignableFrom(t) && t != controllerBaseType)
.PropertiesAutowired() // 允许属性注入
.EnableClassInterceptors(); // 允许在Controller类上使用拦截器
// 手动高亮
builder.RegisterBuildCallback(container => _container = container);
}
public static IContainer GetContainer()
{
return _container;
}
}
