如何将 Autofac 整合进 Net6.0 Core MVC 项目中

深藏阁楼爱情的钟 2024-03-16 14:43 44阅读 0赞

**一、前言**  
　　　　**1、简而言之**  
　　　　　　　　Asp.Net Core Mvc，我也用了很长一段时间了，它现在的编程模型和方式还是特别棒的，都是组件开发，什么都可以替换，当然了，您别抬杠，有些还是不能替换的。自从我们进入了跨平台开发的时代，IOC容器也成了一个不可或缺的东西了。微软为我们提供了一个默认实现，那就是 IServiceCollection，当时我们可以替换掉它，今天我就试试，替换一下，把我的一些经验也写出来，以防以后忘记，不知道去哪里找了。  
　　　　　　　　当然了，这个不是很难，也希望高手不要见笑，对于我来说，好记性不如烂笔头，好的东西我就记录下来，有使用的地方，可以直接来找。  
  
　　　　**2、开发环境。**  
　　　　　　　　我的开发环境没有发生变化，具体如下：  
　　　　　　　　　　操作系统：Windows10 Professional  
　　　　　　　　　　开发平台：Asp.Net Core Mvc 6.0  
　　　　　　　　　　开发语言：C\#  
　　　　　　　　　　开发工具：Visual Studio 2022  
  
**二、操作步骤**  
  
　　　　**1、第一，我们当然要新建一个 Asp.Net Core MVC 的项目，项目都没有，其他的都是胡扯了，我项目的名称是：PatrickLiu.Autofac.MvcConcordance。**

![adb41f76f0a695dd49ed122923d0e66f.png][]

**2、我们为我们的项目增加相应的程序包。分别是：Autofac、Autofac.Extensions.DependencyInjection、Autofac.Extras.DynamicProxy，Castle.Core**  
　　　　　　　　1】、**Autofac** 提供最基础、最核心的功能。  
　　　　　　　　2】、**Autofac.Extensions.DependencyInjection 提供和 Asp.Net Core MVC 集成的接口。**  
　　　　　　　　3】、**Autofac.Extras.DynamicProxy** 提供对AOP的支持，通过动态代理实现。  
　　　　　　　　4】、**Castle.Core** 实现针对 Core 版本的支持，也是支持 AOP 的必需组件。

![9e8e328fee6eca6c56f0baa0efb4c978.png][]

3、这部分是重点，在 Program 程序中配置。具体代码在里面，很简单，就不多说了。

![06ff01a2d40e5e39b93f9a577200b3c3.gif][]

1 using Autofac;
     2 using Autofac.Extensions.DependencyInjection;
     3 using Autofac.Extras.DynamicProxy;
     4 using Castle.DynamicProxy;
     5 using Microsoft.AspNetCore.Mvc;
     6 using Microsoft.AspNetCore.Mvc.Controllers;
     7 using PatrickLiu.Autofac.Contracts;
     8 using PatrickLiu.Autofac.Extensions;
     9 using PatrickLiu.Autofac.Extensions.Aops;
    10 using PatrickLiu.Autofac.Models;
    11 
    12 var builder = WebApplication.CreateBuilder(args);
    13 builder.Services.AddControllersWithViews();
    14 
    15 #region 整合 Autofac
    16 
    17 builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
    18 
    19 builder.Host.ConfigureContainer<ContainerBuilder>(builder =>
    20 {
    21     builder.RegisterType<ChiesePerson>().As<IPerson>();
    22     builder.RegisterType<SinglePerson>();
    23 
    24     #region 服务类型支持属性注入，红色表示是对属性注入的支持，哪个类型需要属性注入，在注册的时候使用 PropertiesAutowired()方法，里面参数是属性选择器。
    ，25 
    26     builder.RegisterType<PropertyPerson>().As<IPropertyPerson>().PropertiesAutowired(new CustomPropertySelector());
    27     builder.RegisterType<PropertyTwoPerson>().As<IPropertyTwoPerson>();
    28     builder.RegisterType<PropertyThreePerson>().As<IPropertyThreePerson>();
    29     builder.RegisterType<SinglePerson>();
    30 
    31     #endregion
    32 
    33     #region AOP支持，红色标注的是关键实现。
    34 
    35     builder.RegisterType<AOPPerson>().As<IAOPPerson>().EnableInterfaceInterceptors();
    36     builder.RegisterType<AOPClassPerson>().As<IAOPClassPerson>().EnableClassInterceptors(new ProxyGenerationOptions()
    37     {
    38         Selector = new CustomInterceptorSelector()
    39     });
    40     builder.RegisterType<AOPCachePerson>().As<IAOPCachePerson>().EnableClassInterceptors();
    41 
    42     builder.RegisterType<CustomClassInterceptor>();
    43     builder.RegisterType<CustomInterfaceInterceptor>();
    44     builder.RegisterType<CustomCacheInterceptor>();
    45 
    46     #endregion
    47 
    48     #region 单接口多实例
    49 
    50     builder.RegisterType<MultiPerson>().Keyed<IMultiPerson>("MultiPerson");
    51     builder.RegisterType<MultiTwoPerson>().Keyed<IMultiPerson>("MultiTwoPerson");
    52     builder.RegisterType<MultiThreePerson>().Keyed<IMultiPerson>("MultiThreePerson");
    53 
    54     #endregion
    55 
    56     #region 让控制器支持属性注入
    57 
    58     var controllerBaseType = typeof(ControllerBase);
    59     builder.RegisterAssemblyTypes(typeof(Program).Assembly)
    60     .Where(t => controllerBaseType.IsAssignableFrom(t) && controllerBaseType != t)
    61     .PropertiesAutowired(new CustomPropertySelector());
    62 
    63     builder.RegisterType<ServiceBasedControllerActivator>().As<IControllerActivator>();
    64 
    65     #endregion
    66 });
    67 
    68 #region 支持 Autofac 属性注入，该方法可以使用，也可以不使用。作用是我们的控制器要使用 Autofac 容器来创建，替换原始的 Controller 激活器。
    69 
    70 //builder.Services.AddTransient<IControllerActivator, ServiceBasedControllerActivator>();
    71 //builder.Services.Replace(ServiceDescriptor.Transient<IControllerActivator, ServiceBasedControllerActivator>());
    72 
    73 #endregion
    74 
    75 #endregion
    76 
    77 var app = builder.Build();
    78 
    79 app.UseStaticFiles();
    80 
    81 app.UseRouting();
    82 
    83 app.MapControllerRoute("default", "{controller=AOP}/{action=index}/{id?}");
    84 
    85 app.Run();

![f8ef897e58be25c1ee8719ec8971409c.gif][]

**4、Autofac 支持属性注入，默认是所有属性的类型如果是注册的服务类型，就会全部赋值，但是，我们也可以实现 IPropertySelector 接口，自定义哪个属性需要注入。**

![a7439f84e6e29d21c30e82947b0db520.gif][]

1 using Autofac.Core;
     2 using System.Reflection;
     3 
     4 namespace PatrickLiu.Autofac.Extensions
     5 {
     6     public sealed class CustomPropertySelector : IPropertySelector
     7     {
     8         public bool InjectProperty(PropertyInfo propertyInfo, object instance)
     9         {
    10             return propertyInfo.IsDefined(typeof(CustomPropertySelectorAttribute), false);
    11         }
    12     }
    13 }

![0c0c8f62bba44cdf401b211ac11f5303.gif][]

有了选择器，我们也需要定义特性（Attribute），标注属性（Property）就可以。

![33ed3a88b7ec993562e8cf7c18d860c1.gif][]

1 namespace PatrickLiu.Autofac.Extensions
     2 {
     3     /// <summary>
     4     /// 
     5     /// </summary>
     6     [AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
     7     public sealed class CustomPropertySelectorAttribute : Attribute
     8     {
     9     }
    10 }

![f8ef897e58be25c1ee8719ec8971409c.gif][]

有了这两个，我们在把我们自定义的属性选择器 CustomPropertySelector 作为参数，传递给 PropertiesAutowired(new CustomPropertySelector())方法，就完成操作了。

![f8ef897e58be25c1ee8719ec8971409c.gif][]

1 using Microsoft.AspNetCore.Mvc;
     2 using PatrickLiu.Autofac.Contracts;
     3 using PatrickLiu.Autofac.Extensions;
     4 using PatrickLiu.Autofac.Models;
     5 
     6 namespace PatrickLiu.Autofac.MvcConcordance.Controllers
     7 {
     8     /// <summary>
     9     /// 
    10     /// </summary>
    11     public class PropertyInjectionController : Controller
    12     {
    13         private readonly IPropertyPerson _propertyPerson;
    14 
    15         /// <summary>
    16         /// 
    17         /// </summary>
    18         /// <param name="propertyPerson"></param>
    19         public PropertyInjectionController(IPropertyPerson propertyPerson)
    20         {
    21             _propertyPerson = propertyPerson;
    22         }
    23 
    24         /// <summary>
    25         /// 这里就是控制器的属性，需要自动初始化。
    26         /// </summary>
    27         [CustomPropertySelector]
    28         public SinglePerson? SinglePerson { get; set; }
    29 
    30         /// <summary>
    31         /// 
    32         /// </summary>
    33         /// <returns></returns>
    34         public IActionResult Index()
    35         {
    36             _propertyPerson.Process();
    37 
    38             return View();
    39         }
    40     }
    41 }

![dc62813fe7f4edcb75473147bb03737c.gif][]

5、Autofac 支持两种类型 AOP，分别是：EnableClassInterceptors 和 EnableInterfaceInterceptors ，类拦截器必须使用 \[Intercept(typeof(CustomClassInterceptor))\]标注需要实现 AOP 的实现类上，如果是接口拦截器，就必须将 \[Intercept(typeof(CustomInterfaceInterceptor))\] 标注在需要实现 AOP 的接口类型上。  
　　　　　　　　1】、EnableClassInterceptors：类拦截器，它的方法必须是 virtual 虚方法，才可以支持 AOP。  
　　　　　　　　2】、EnableInterfaceInterceptors：接口拦截器，没有相关限制，该接口的实现类的方法都会实现 AOP。  
　　　　　　　　这就是接口拦截器。

![f1de7fa0a9eae2ad5d2d851024bbe08f.gif][]

1 using Autofac.Extras.DynamicProxy;
     2 using PatrickLiu.Autofac.Extensions.Aops;
     3 
     4 namespace PatrickLiu.Autofac.Contracts
     5 {
     6     /// <summary>
     7     /// 
     8     /// </summary>
     9     [Intercept(typeof(CustomInterfaceInterceptor))]
    10     public interface IAOPPerson
    11     {
    12         /// <summary>
    13         /// 
    14         /// </summary>
    15         void Process();
    16 
    17         /// <summary>
    18         /// 
    19         /// </summary>
    20         void ProcessTwo();
    21 
    22         /// <summary>
    23         /// 
    24         /// </summary>
    25         void ProcessThree();
    26     }
    27 }

![61c5296581539375d0103d9feac9d7da.gif][]

以下是类拦截器。

![2dcb9eec1053e1f14a6f98bcdf083607.gif][]

1 using Autofac.Extras.DynamicProxy;
     2 using PatrickLiu.Autofac.Contracts;
     3 using PatrickLiu.Autofac.Extensions.Aops;
     4 
     5 namespace PatrickLiu.Autofac.Models
     6 {
     7     /// <summary>
     8     /// 
     9     /// </summary>
    10     [Intercept(typeof(CustomClassInterceptor))]
    11     public class AOPClassPerson : IAOPClassPerson
    12     {
    13         /// <summary>
    14         /// 
    15         /// </summary>
    16         public virtual void ProcessAOP()
    17         {
    18             Console.WriteLine("AOPClassPerson.ProcessAOP()");
    19         }
    20 
    21         /// <summary>
    22         /// 
    23         /// </summary>
    24         public void Process()
    25         {
    26             Console.WriteLine("AOPClassPerson.Process()");
    27         }
    28     }
    29 }

![cca5075333231506d1075165169c5a09.gif][]

**6、我们要自定义我们的拦截器，然后再标注的类型标注 \[Intercept(typeof(自定义拦截器))\]，就可以使用，我分别定义了两个拦截器，一个用于类，一个用于接口，其实没有本质区别，实现的接口都是一样的，该接口就是：IInterceptor。**

![f8ef897e58be25c1ee8719ec8971409c.gif][]

1 using Castle.DynamicProxy;
     2 
     3 namespace PatrickLiu.Autofac.Extensions.Aops
     4 {
     5     /// <summary>
     6     /// 类级别的拦截器，标注在要实现AOP功能的类型上。
     7     /// </summary>
     8     public sealed class CustomClassInterceptor : IInterceptor
     9     {
    10         /// <summary>
    11         /// 
    12         /// </summary>
    13         /// <param name="invocation"></param>
    14         public void Intercept(IInvocation invocation)
    15         {
    16             {
    17                 Console.WriteLine("CustomClassInterceptor.Before");
    18             }
    19             invocation.Proceed();
    20             {
    21                 Console.WriteLine("CustomClassInterceptor.After");
    22             }
    23         }
    24     }
    25 }

![06ff01a2d40e5e39b93f9a577200b3c3.gif][]

![305000571f40fa69c4f6b56bbc2288ad.gif][]

1 using Castle.DynamicProxy;
     2 
     3 namespace PatrickLiu.Autofac.Extensions.Aops
     4 {
     5     /// <summary>
     6     /// 接口级别的拦截器，标注在要实现AOP功能的接口类型上。
     7     /// </summary>
     8     public sealed class CustomInterfaceInterceptor : IInterceptor
     9     {
    10         /// <summary>
    11         /// 
    12         /// </summary>
    13         /// <param name="invocation"></param>
    14         public void Intercept(IInvocation invocation)
    15         {
    16             {
    17                 Console.WriteLine("CustomInterfaceInterceptor.Before");
    18             }
    19             invocation.Proceed();
    20             {
    21                 Console.WriteLine("CustomInterfaceInterceptor.After");
    22             }
    23         }
    24     }
    25 }

![e7093152f04d0aa44a7e3e4459d35f50.gif][]

7、当然，我们也可以不标注 **\[Intercept(typeof(自定义拦截器))\]，我们可以实现 IInterceptorSelector 接口，实现自定义使用哪些拦截器。代码如下：**

![f1de7fa0a9eae2ad5d2d851024bbe08f.gif][]

1 using Castle.DynamicProxy;
     2 using System.Reflection;
     3 
     4 namespace PatrickLiu.Autofac.Extensions.Aops
     5 {
     6     /// <summary>
     7     /// 
     8     /// </summary>
     9     public class CustomInterceptorSelector : IInterceptorSelector
    10     {
    11         /// <summary>
    12         /// 
    13         /// </summary>
    14         /// <param name="type"></param>
    15         /// <param name="method"></param>
    16         /// <param name="interceptors">如果类型有标注拦截器，这里会获取所有拦截器。</param>
    17         /// <returns></returns>       
    18         public IInterceptor[] SelectInterceptors(Type type, MethodInfo method, IInterceptor[] interceptors)
    19         {
    20             IList<IInterceptor> interceptorsList = new List<IInterceptor>();
    21             interceptorsList.Add(new CustomInterfaceInterceptor());
    22 　　　　　　　在这个方法里面，我们可以过滤拦截器，想是哪个起作用哪个就起作用。返回的拦截器，就是起作用的拦截器。
    23             return interceptorsList.ToArray();
    24         }
    25     }
    26 }

![13c6f9e9e666d25ba691ee616b89dd6e.gif][]

我们可以选择拦截器，也需要在Program 里体现，builder.RegisterType<AOPClassPerson>().As<IAOPClassPerson>().EnableClassInterceptors(new ProxyGenerationOptions() \{ Selector = new CustomInterceptorSelector() \});  
  
　　　　**8、Autofac 默认支持构造函数注入，如果有多个构造函数，如果构造函数的参数都是需要注入的服务类型，默认选择依赖注册服务参数最多的构造函数会被执行。当然我们也可以选择指定的构造函数来初始化类型实例，该方法就是 .UsingConstructor(typeof(参数类型))。**

builder.RegisterType<ChiesePerson>().As<IPerson>().UsingConstructor(typeof(int));

![c69c0c8bc5e42ce50c885bd621b99b44.gif][]

1 using Autofac;
     2 using Microsoft.AspNetCore.Mvc;
     3 using PatrickLiu.Autofac.Contracts;
     4 using PatrickLiu.Autofac.Models;
     5 
     6 namespace PatrickLiu.Autofac.MvcConcordance.Controllers
     7 {
     8     /// <summary>
     9     /// 
    10     /// </summary>
    11     public class HomeController : Controller
    12     {
    13         private readonly IPerson _person;
    14         private readonly IServiceProvider _serviceProvider;
    15         private readonly IComponentContext _componentContext;
    16 
    17         /// <summary>
    18         /// 
    19         /// </summary>
    20         /// <param name="person"></param>
    21         /// <param name="serviceProvider">服务提供器，类型是 AutofacServiceProvider，获取类型。</param>
    22         /// <param name="componentContext">autofac 的上下文对象，可以获取容器中的服务。</param>
    23         public HomeController(IPerson person, IServiceProvider serviceProvider, IComponentContext componentContext)
    24         {
    25             _person = person;
    26             _serviceProvider = serviceProvider;
    27             _componentContext = componentContext;
    28         }
    29 
    30         public IActionResult Index()
    31         {
    32             _person.Eat("炸酱面");
    33 
    34             var single=_serviceProvider.GetService<SinglePerson>();
    35             single!.Eat("残羹冷炙");
    36 
    37             var singleTwo=_componentContext.Resolve<SinglePerson>();
    38             singleTwo.Eat("残羹剩饭");
    39 
    40             return View();
    41         }
    42     }
    43 }

![4b6494ced199e5b2b8f1df66b72a46c4.gif][]

**三、结束语**  
　　　　平台本身提供了自己的容器实现，当然，我们也可以替换它，使用其他的 IOC容器。不学不知道，一学吓一跳，东西还有很多不知道了。平凡的我，只能继续努力，苍天不负有心人，努力就会有回报。不忘初心，继续努力吧。

[adb41f76f0a695dd49ed122923d0e66f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/fed5b6b0ded443bc99064b70b0d11c95.png
[9e8e328fee6eca6c56f0baa0efb4c978.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/250fb75ec8804c5f93ac5558054a7053.png
[06ff01a2d40e5e39b93f9a577200b3c3.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/f9dc8f5135b84856a40e9a2ea657e148.png
[f8ef897e58be25c1ee8719ec8971409c.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/8fa4f50e41f64e7bbb241e8da4c96ec8.png
[a7439f84e6e29d21c30e82947b0db520.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/08049d810a8a4483933a2e72397dc84d.png
[0c0c8f62bba44cdf401b211ac11f5303.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/32464e1ad94049489bd2a1307704f68e.png
[33ed3a88b7ec993562e8cf7c18d860c1.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/d648fda1bbbe4911aca192e92408fa66.png
[dc62813fe7f4edcb75473147bb03737c.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/c351da1768ad4007856e8ebd09115408.png
[f1de7fa0a9eae2ad5d2d851024bbe08f.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/3fde897073ed49dd9a9555c29956eed4.png
[61c5296581539375d0103d9feac9d7da.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/2b364dc167a449ce835208705f87f712.png
[2dcb9eec1053e1f14a6f98bcdf083607.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/8ccee586ab714ba2803274a061bbf3ea.png
[cca5075333231506d1075165169c5a09.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/89ba4cba15a542f496ecacfcbd3d461d.png
[305000571f40fa69c4f6b56bbc2288ad.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/b53d01364fab493ebc0c19e9fafba1f6.png
[e7093152f04d0aa44a7e3e4459d35f50.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/17ea3e7d4c924d719b747422a8194d30.png
[13c6f9e9e666d25ba691ee616b89dd6e.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/3747015e4b1545bb9f18e97344c7f13d.png
[c69c0c8bc5e42ce50c885bd621b99b44.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/1aff411986be4ae4a63ab229f7bff0ca.png
[4b6494ced199e5b2b8f1df66b72a46c4.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/c973f371a2464375b72ed91562bbe79a.png