c#中的IOC容器之Autofac容器

IOC（inversion of control）控制反转

以前我们把框架分为三层架构：UI层，BLL层，DAL层。在三层架构中我们，我们是一层一层的调用对象里面的方法，需要实例化对象：类名  对象名 = new 类名()；这种叫传统工艺。
现在我们不需要在依赖某一个类来获取到实例。而是依赖于抽象，怎么获取？交给了第三方（称：IOC容器）通过抽象（接口，抽象类，普通父类）的方式获取到类的实例。
IOC内置容器：ServiceCollection
1.创建库类接口【Interfaces】里面什么都不写，只是做依赖注入的关系

public interface IMicrophone{ }

2.创建一个服务类库【Services】做我们需要调用的具体对象

public class Microphone: IMicrophone
{
     public Microphone() { Console.WriteLine($"{this.GetType().Name}被构造了"); }
}

3.通过容器依赖注入到项目中来

using Interfaces;//接口类库
using Services;//服务类库
using Microsoft.Extensions.DependencyInjection;//内置IOC容器

ServiceCollection service = new ServiceCollection();//1.创建一个容器，需要nuget引入：Microsoft.Extensions.DependencyInjection
service.AddTransient<IMicrophone, Microphone>();//2.建立关系或是注册抽象和具体普通类之间的关系,注册方式有很多，这里只是其中一种
ServiceProvider sp = service.BuildServiceProvider();//3.进行集中管理，统一注入到ServiceProvider，而BuildServiceProvider就是获取依赖关系
IMicrophone microphone= sp.GetService<IMicrophone>();//4.获取抽象的具体实例，就相当于Microphone被实例化后的具体对象，通过接口抽象出来的

传统工艺：new 实例化对象。对象创建在项目中是多个地方的。
ioc容器可以在全局，配置抽象和具体普通类之间的关系，是可以修改AddTransient<抽象, 具体类>();修改为什么获取的就是什么。
ioc容器，最大的好处在于DI依赖注入：如果A依赖于B，B依赖于C；那么在创建A时，会把C先创建出来交给B，在把B创建出来交给A，从而创建出A对象来。

public interface IHeadphone{ }//接口

public class Headphone : IHeadphone //依赖于IPower
{
    public Headphone(IPower power) { Console.WriteLine($"{this.GetType().Name}被构造了"); }
}

Power依赖于IMicrophone

public interface IPower { } //接口

public class Power : IPower
{
    public Power(IMicrophone microphone) { Console.WriteLine($"{this.GetType().Name}被构造了"); }
}

Microphone有继承了IMicrophone

public interface IMicrophone{ }//接口

public class Microphone: IMicrophone
{
    public Microphone() { Console.WriteLine($"{this.GetType().Name}被构造了"); }
}

这种依赖注入关系叫构造函数注入

using Interfaces;//接口类库
using Services;//服务类库
using Microsoft.Extensions.DependencyInjection;//内置IOC容器

Console.WriteLine("传统工艺，实例化对象-------------------");
IMicrophone m =new Microphone();
IPower p = new Power(m);
IHeadphone h = new Headphone(p);

Console.WriteLine("IOC容器支持的依赖注入-----------------------");
ServiceCollection service = new ServiceCollection();//1.创建容器：ioc容器本质就是个工厂用来创建对象的
service.AddTransient<IMicrophone, Microphone>();//2.建立关系
service.AddTransient<IPower, Power>();
service.AddTransient<IHeadphone, Headphone>();
ServiceProvider sp = service.BuildServiceProvider();//3.进行集中管理，获取依赖关系
IHeadphone headphone = sp.GetService<IHeadphone>();//4.获取实例

依赖注入有三种【1.构造函数注入；2.方法注入；3.属性注入】但内置ioc容器只支持构造函数注入，其他两种只能去扩展
ServiceCollection的生命周期

ServiceCollection service = new ServiceCollection();
service.AddTransient<IMicrophone, Microphone>();//Transient:瞬时生命周期，每一次创建都是新的实例
service.AddSingleton<IHeadphone, Headphone>();//Singleton：单例的生命周期,相同的一个引用地址，同一对象实例
service.AddScoped<IPower, Power>();//Scoped:作用域生命周期，保存在相同的ServiceProvider对象里，获取是相同的实例，反之不同
ServiceProvider sp = service.BuildServiceProvider();//获取依赖关系保存到对象
IMicrophone m1 = sp.GetService<IMicrophone>(); 
IMicrophone m2 = sp.GetService<IMicrophone>();
Console.WriteLine($"Transient:瞬时生命周期比较m1和m2是否一样：{object.ReferenceEquals(m1,m2)}");
IHeadphone h1 = sp.GetService<IHeadphone>();
IHeadphone h2 = sp.GetService<IHeadphone>();
Console.WriteLine($"Singleton:单例生命周期比较h1和h2是否一样：{object.ReferenceEquals(h1, h2)}");
IPower p1 = sp.GetService<IPower>();
IPower p2 = sp.GetService<IPower>();
Console.WriteLine($"Scoped:作用域生命周期比较p1和p2是否一样：{object.ReferenceEquals(p1, p2)}");

ServiceCollection的多种注册：上面使用的是泛型注册

ServiceCollection service = new ServiceCollection();
service.AddTransient(typeof(IMicrophone), typeof(Microphone));//方法注册和泛型注册一样的
service.AddTransient(typeof(Microphone));//可以直接给个具体实例，调用也是实例
service.AddTransient<Microphone>();//泛型注册，也可以直接给一个实例
service.AddTransient(typeof(IPower), a => { //委托，注册抽象和一段业务逻辑
    //在这里我们可以直接来决定创建这个对象的实例，可以对这个实例做加工。
    IMicrophone m = a.GetService<IMicrophone>();
    return new Power(m);
});
ServiceProvider sp = service.BuildServiceProvider();
IMicrophone m1 = sp.GetService<IMicrophone>();
Microphone m2 = sp.GetService<Microphone>();//泛型注册也是一样的，可以直接给一个实例
IPower p = sp.GetService<IPower>();

ServiceCollection容器在asp.net core中的使用：首先在【Program.cs】

builder.Services.AddTransient<IMicrophone, Microphone>();//依赖：在顶级程序中注册内置ioc容器。

注入：到控制器（构造方法）中注入使用

private readonly IMicrophone microphone;public HomeController(IMicrophone microphone, IServiceProvider sp)//home控制器的构造方法
{
    this.microphone = microphone;//方法1：注入进来的ioc容器
    this.microphone = sp.GetService<IMicrophone>();//方法2：:这两种获取方式是一样
}

Autofac

新的容器替代内置容器，需要引入：Autofac

ContainerBuilder containerBuilder = new ContainerBuilder();//实例化对象ioc容器，需要引入：Autofac
containerBuilder.RegisterType<Microphone>().As<IMicrophone>();//配置关系
IContainer container = containerBuilder.Build();//获取关系存放在集合中
IMicrophone microphone = container.Resolve<IMicrophone>();//获取实例

多种注册

ContainerBuilder containerBuilder = new ContainerBuilder();//创建：ioc容器对象
containerBuilder.RegisterInstance(new Microphone());//方法1,：注册一个具体实例

containerBuilder.RegisterType<Microphone>().As<IMicrophone>();//方法2：建立接口和实例的关系,然后委托一段业务逻辑
containerBuilder.Register<IPower>(context => {//委托，注册一段业务逻辑
    //这里的业务逻辑创建出IPower的实例----给一个入口，自己创建出对象的实例
    IMicrophone microphone = context.Resolve<IMicrophone>();
    IPower power = new Power(microphone);
    return power;
});

containerBuilder.RegisterGeneric(typeof(List<>)).As(typeof(IList<>));//方法3：注册泛型

IContainer container = containerBuilder.Build();//获取关系，保存到集合

IMicrophone microphone = container.Resolve<IMicrophone>();//1.接口和实例关系创建的
IPower power = container.Resolve<IPower>();//2.注册一段业务逻辑
IList<IMicrophone> mlist = container.Resolve<IList<IMicrophone>>();//3.注册泛型

Assembly程序集注册，需要引入：System.Reflection;

using Interfaces;//接口类库
using Services;//服务类库
using Autofac;//ioc容器
using System.Reflection;//Assembly获取程序集

ContainerBuilder containerBuilder = new ContainerBuilder();//创建：ioc容器对象
Assembly InterfaceAssembly = Assembly.LoadFrom("Interfaces.dll");//接口程序集
Assembly serviceAssembly = Assembly.LoadFrom("Services.dll");//实例类程序集
containerBuilder.RegisterAssemblyTypes(InterfaceAssembly, serviceAssembly).AsImplementedInterfaces();//建立程序集关系
IContainer container = containerBuilder.Build();//获取关系，保存到集合
IEnumerable<IMicrophone> microphone = container.Resolve<IEnumerable<IMicrophone>>();//泛型实例，普通实例也可以

依赖注入：依赖指的是上面的ioc容器建立的依赖关系；注入【1.构造函数注入，2.方法注入，3.属性注入】
1.构造函数注入：UsingConstructor( )

public class Power : IPower
{
    private readonly IMicrophone microphone;//通过ioc容器注入进来的实例
    public Power(IMicrophone microphone)
    { //这种叫构造函数注入this.microphone = microphone;
    }
}

如果有多个构造函数【默认选择参数最多的构造函数】如果需要指定执行的构造函数，注册时需要调用：UsingConstructor( ) 方法来决定执行哪个构造函数

ContainerBuilder containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType<Microphone>().As<IMicrophone>();//UsingConstructor指定多少参数就能行哪个构造函数，默认执行最多参数的构造函数
containerBuilder.RegisterType<Power>().As<IPower>().UsingConstructor(typeof(IMicrophone));//指定执行的构造函数必须只有一个参数类型为：IMicrophone
IContainer container = containerBuilder.Build();
IPower microphone = container.Resolve<IPower>();

2.属性注入：PropertiesAutowired() ----------所有属性都注入

ContainerBuilder containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType<Microphone>().As<IMicrophone>();
containerBuilder.RegisterType<Power>().As<IPower>().PropertiesAutowired();//指定：属性注入
IContainer container = containerBuilder.Build();
IPower microphone = container.Resolve<IPower>();

public class Power : IPower
{
    public IMicrophone microphone { get; set; }//属性注入直接传进属性来的
    public Power() //参数不需要传
    {
    }
}

指定属性注入（PropertySelector接口）：首先创建一个【特性】用于做属性注入的标记，哪个属性标记了这个特性，就代表这个属性支持属性注入，否则就是普通属性

[AttributeUsage(AttributeTargets.Property)]//声明特性只能标记在属性上面有效
public class CusotmSelectAttribute : Attribute { }//做标记；表示谁使用了这个特性谁就支持属性注入，否则就是普通属性

public class CusotmPropertySelector : IPropertySelector
{//在这里面判断哪些属性是需要做属性注入
    public bool InjectProperty(PropertyInfo propertyInfo, object instance)
    {
        return propertyInfo.CustomAttributes.Any(c => c.AttributeType == typeof(CusotmSelectAttribute));//标记了这个特性，就需要实现注入
    }
}

在注册依赖关系时让PropertySelector生效

containerBuilder.RegisterType<Power>().As<IPower>().PropertiesAutowired(new CusotmPropertySelector());//指定属性注入

特性的引用

public class Power : IPower
{
    [CusotmSelectAttribute]//指定了属性注入
    public IMicrophone microphone { get; set; }//这个是注入后的实例
    public IHeadphone headphone { get; set; }//就是个普通属性
    public Power() //参数不需要传
    {
    }
}

 3、方法注入：OnActivated(委托)；在构造出某一个对象后，自动去调用对象的某一个方法，方法需要什么参数，自动构造出来，传入参数。

ContainerBuilder containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType<Microphone>().As<IMicrophone>();
containerBuilder.RegisterType<Power>().As<IPower>().OnActivated(active => { //指定字段与方法行成依赖关系
    IMicrophone micro = active.Context.Resolve<IMicrophone>();//Context从上下文中获取到实例
    active.Instance.index111(micro);//使用index111方法
});
IContainer container = containerBuilder.Build();
IPower microphone = container.Resolve<IPower>();

public class Power : IPower
{
    public IMicrophone _microphone;//字段必须是公开的public
    public Power() //参数不需要传，同时也支持构造方法注入，传进来也一样可以获取
    {
    }
    public void index111(IMicrophone microphone)//和构造方法注入类似
    {
        this._microphone = microphone;
    }
}

单抽象多实现：默认创建出的对象，是最后注册的服务关系。

ContainerBuilder containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType<Microphone>().As<IMicrophone>();//Microphone继承接口IMicrophone
containerBuilder.RegisterType<Headphone>().As<IMicrophone>();//Headphone也继承接口IMicrophone
IContainer container = containerBuilder.Build();
IMicrophone microphone = container.Resolve<IMicrophone>();//这么默认获取到最后一个实例，也就是Headphone
IEnumerable<IMicrophone> m = container.Resolve<IEnumerable<IMicrophone>>();//想获取多个就使用可迭代泛型

如果需要获取某个实例，可以指定一个标识Keyed

ContainerBuilder containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType<Microphone>().Keyed<IMicrophone>("Microphone");//指定一个标识
containerBuilder.RegisterType<Headphone>().Keyed<IMicrophone>("Headphone");
IContainer container = containerBuilder.Build();
IMicrophone m = container.ResolveKeyed<IMicrophone>("Microphone");//获取标识
IMicrophone h = container.ResolveKeyed<IMicrophone>("Headphone");//如果是集合获取也需要指定标识ResolveKeyed

 想在mvc里使用Autofac还需要引用：Autofac.Extensions.DependencyInjection 替换内置工厂

builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());//1.通过工厂替换为Autofac（把内置的AOP替换掉）
builder.Host.ConfigureContainer<ContainerBuilder>(containerBuilder => { //2.创建一个工厂
    containerBuilder.RegisterType<Microphone>().As<IMicrophone>();//3.注册关系
});

控制器中构造方法调用（3种注入方式）

private readonly IMicrophone microphone;
private readonly IEnumerable<IMicrophone> list;
private readonly IServiceProvider sp;

public HomeController(IMicrophone microphone, IEnumerable<IMicrophone> list, IServiceProvider sp, IComponentContext componentContext)
{
    this.microphone = microphone;
    this.sp = sp;
    this.list = list;
    IMicrophone m = sp.GetService<IMicrophone>();
    IMicrophone m2 = componentContext.Resolve<IMicrophone>();//Autofac的上下文也可以注入
}

 属性注入（特性上面写了就不写了）

builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
builder.Host.ConfigureContainer<ContainerBuilder>(containerBuilder => { 
    containerBuilder.RegisterType<Microphone>().As<IMicrophone>();

    //2.注册某个控制器和抽象之间的关系
    var controllerBaseType = typeof(ControllerBase);//控制器都继承他，借用这个父类来识别是否是控制器。
    containerBuilder.RegisterAssemblyTypes(typeof(Program).Assembly)//注册程序集（当前控制台所在的程序集）
    .Where(t => controllerBaseType.IsAssignableFrom(t) && t != controllerBaseType)//找到的是控制器，ControllerBase类型，但又不等于他
    .PropertiesAutowired(new CusotmPropertySelector());//支持属性注入，这里就可以在属性上面标注特性了。
});
//1.支持控制器的这个实例让ioc容器来创建---其实就是让Autofac来创建
builder.Services.Replace(ServiceDescriptor.Transient<IControllerActivator, ServiceBasedControllerActivator>());//扩展作用是替换（参数1的事交给参数2来处理）

[CusotmSelectAttribute]
public IMicrophone microphone { get; set; }

三、Autofac支持AOP

需要先引入程序包：Castle.Core 还需要引入：Autofac.Extras.DynamicProxy 来支持AOP扩展

public class CusotmInterceptor : IInterceptor//切入者逻辑
{//这个是Autofac支持AOP的扩展方法，需要引入：Castle.Core
    public void Intercept(IInvocation invocation)
    {
        Console.WriteLine("call方法之前执行");
        invocation.Proceed();//执行call方法
        Console.WriteLine("call方法之后执行");
    }
}

注册时调用：EnableClassInterceptors() 方法他们叫拦截器--------标记在类中，只对虚方法有效

builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
builder.Host.ConfigureContainer<ContainerBuilder>(containerBuilder => {
    containerBuilder.RegisterType<Microphone>().As<IMicrophone>().EnableClassInterceptors();//支持aop扩展必须调用此方法。只会拦截虚方法。
    containerBuilder.RegisterType<CusotmInterceptor>();//把aop扩展方法也注入进来才能使用,里面写方法前后执行动作。
});

using Autofac.Extras.DynamicProxy;
using Interfaces;
namespace Services
{
    [Intercept(typeof(CusotmInterceptor))]//指定被aop扩展，EnableClassInterceptors标记在类中，只对类中的虚方法有有效
    public class Microphone: IMicrophone
    {
        public Microphone() { Console.WriteLine($"{this.GetType().Name}被构造了"); }
        public virtual void call() { Console.WriteLine("call方法以执行,必须定义为虚方法才支持aop扩展。"); }
        public void ca() { Console.WriteLine("普通方法不是虚方法，不支持aop扩展。"); }//实现接口的两个方法
    }
}

EnableInterfaceInterceptors()-----------------------------标记在接口，对私有实现接口方法有效。

builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
builder.Host.ConfigureContainer<ContainerBuilder>(containerBuilder => {
    containerBuilder.RegisterType<Microphone>().As<IMicrophone>().EnableInterfaceInterceptors();//标记在接口，对私有实现接口方法有效。
    containerBuilder.RegisterType<CusotmInterceptor>();//把aop扩展方法也注入进来才能使用,里面写方法前后执行动作。
});

using Autofac.Extras.DynamicProxy;
namespace Interfaces
{
    [Intercept(typeof(CusotmInterceptor))]//EnableInterfaceInterceptors()标记在接口，对私有实现接口方法有效
    public interface IMicrophone{
        void call();
        void ca();
    }
}

控制台的注入

public class HomeController : Controller
{
    private readonly IMicrophone microphone;
    public HomeController(IMicrophone microphone)
    {
        this.microphone = microphone;
    }
    public IActionResult Index()
    {
        microphone.call();//虚方法
        microphone.ca();//普通方法

        return View();
    }
}

 在项目中可以做为日志记录，记录方法的动态变化

using Castle.Core.Logging;
using Castle.DynamicProxy;
using Microsoft.Extensions.Logging;

namespace Interfaces
{
    public class CusotmInterceptor : IInterceptor//切入者逻辑
    {//这个是Autofac支持AOP的扩展方法，需要引入：Castle.Core
        private readonly ILogger<CusotmInterceptor> logger;

        public CusotmInterceptor(ILogger<CusotmInterceptor> logger)
        {
            this.logger = logger;
        }
        public void Intercept(IInvocation invocation)
        {
            logger.LogInformation($"参数：{Newtonsoft.Json.JsonConvert.SerializeObject(invocation.Arguments)}");
            logger.LogInformation($"{invocation.Method.Name}方法正在执行");
            invocation.Proceed();//执行call方法
            logger.LogInformation($"{invocation.Method.Name}方法执行完毕");
            logger.LogInformation($"返回值：{Newtonsoft.Json.JsonConvert.SerializeObject(invocation.ReturnValue)}");
        }
    }
}

还可以做缓存处理

public class CusotmInterceptor : IInterceptor//切入者逻辑
{
    private static Dictionary<string, object> cacheDictionary = new Dictionary<string, object>();//记录缓存
    public void Intercept(IInvocation invocation)
    {
        string cacheKey = invocation.Method.Name;//用方法名做钥匙，存在方法就不缓存，不存在就缓存数据。
        if (cacheDictionary.ContainsKey(cacheKey))//如果有缓存
        {
            invocation.ReturnValue = cacheDictionary[cacheKey];//返回缓存的结果。
        }
        else //无缓存
        {
            invocation.Proceed();//执行方法
            cacheDictionary[cacheKey] = invocation.ReturnValue;//记录缓存
        }
    }
}

IInterceptorSelector 扩展，不需要在去类和接口上标记 [Intercept(typeof(CusotmInterceptor))] 就可以做拦截

public class CusotmInterceptorSelector : IInterceptorSelector//IInterceptor的扩展：用来选择切入者逻辑的类简单执行哪一个
{
    public IInterceptor[] SelectInterceptors(Type type, MethodInfo method, IInterceptor[] interceptors)
    {
        //return interceptors;//返回所有，类和接口上标记的都可以获取到。
        return new IInterceptor[] { new CusotmInterceptor() };//也可以选择哪一个切入者，多个在new。
    }
}

还需要ioc容器注册依赖关系

builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
builder.Host.ConfigureContainer<ContainerBuilder>(containerBuilder => {
    containerBuilder.RegisterType<Microphone>().As<IMicrophone>()
    .EnableInterfaceInterceptors(new ProxyGenerationOptions(){ //指定使用的IInterceptor，不需要在去类和接口上标记：[Intercept(typeof(CusotmInterceptor))]
        Selector = new CusotmInterceptorSelector()//指定了选择者，交给这个类来执行我们需要拦截的切入者，指定了就会执行选择者，不需要在标记
    });
    containerBuilder.RegisterType<CusotmInterceptor>();//把aop扩展方法也注入进来才能使用,里面写方法前后执行动作。
});