.NET CORE 容器支持 AOP 和依赖注入

1、内置容器 ServiceColloction （这个容器只支持构造函数注入）

• 引入 ServiceCollection

  ServiceCollection sc = new ServiceCollection();
  

• 注册抽象类和实现类直接的对应关系

sc.AddTransient<抽象类，实现类>();

• 把容器构造出来

ServiceProvider = sp = sc.BuildServiceProvider();

• 可以通过容器获取需要的实现类

 抽象类 ob = sp.GetService<抽象类>();

• ServiceCollection 容器依赖注入的生命周期

//1、瞬时生命周期,每次注入的实例都不一样 
sc.AddTransient<抽象类，实现类>(); ​ 

//2、单例生命周期，每次注入的实例都一样 
sc.AddSingleton<抽象类，实现类>(); ​ 

//3、作用域生命周期，在同一个访问中使用的实例相同 每次创建的 BuildServiceProvider里面使用的实例相同 
sc.AddScoped<抽象类，实现类>();​

2、Autofac 容器

a. Nuget 程序包

b. 得到容器建造者( startUp.cs 的 ConfigureContainer方法来创建容器的时候，可以用方法注入的方式就省去了 ContainerBuilder创建和 build 的步骤)

ContainerBuilder containerBuilder = new ContainerBuilder();

c. 配置抽象和实现类的映射关系

containerBuilder.RegisterType<实现类>().As<抽象类>();

d. Build 一下得到容器实例

Icontainer container = containerBuilder.Build();

e. 基于容器来获取对象的实例

2.1、注册抽象和普通类

ContainerBuilder containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType<实现类>().As<抽象类>();
Icontainer container = containerBuilder.Build();
//获取实例
抽象类 ob = container.Resolve<抽象类>();

2.2、注册具体的实例（可以根据配置参数创建出不同的实例属性）

//可以根据配置参数创建出不同的实例属性
containerBuilder.RegisterInstance(new 实现类());

2.3、注册一段业务逻辑

containerBuilder.RegisterType<抽象类>(context => {
    //根据业务逻辑去创建实例
    抽象类 ob = new 实现类();//根据不同的参数创建出不同的属性
    return ob
});

2.4、注册泛型（IList<T>）

ContainerBuilder containerBuilder = new ContainerBuilder();
containerBuilder.RegisterGeneric(typeof(List<>)).As(typeof(IList<>));
containerBuilder.RegisterType<实现类>().As<抽象类>();//这边注册的实体类能够在容器数组总拿到

Icontainer container = containerBuilder.Build();
//获取实例
IList<抽象类> oblist = container.Resolve<IList<抽象类>>();

2.5、注册程序集

(可以用于直接将外部的程序打包成 dll 文件后直接引用到项目中，而不是外部引用【有什么好处吗】)

ContainerBuilder containerBuilder = new ContainerBuilder();
Assembly interfaceAssemble = Assembly.LoadFrom("抽象程序集的路径"); 
Assembly serviceAssemble = Assembly.LoadFrom("实现程序集的路径"); 

containerBuilder.RegisterAssembly = AssemblyTypes(interfaceAssemble,serviceAssemble).AsImplementInterfaces();
Icontainer container = containerBuilder.Build();

2.6、支持构造函数注入

//1、在容器创建时注入依赖
containerBuilder.RegisterType<实现类>().As<抽象类>();

//2、如果实现类的构造函数有多种，程序默认会创建使用参数最多的构造参数创建对象
//3、想要让程序在注入时使用指定的构造函数创建最想可以使用 UsingConstructor() 来指定构造函数的
containerBuilder.RegisterType<实现类>()
    .UsingConstructor(typeof(string))//指定参数的构造函数
    .As<抽象类>();
    

2.7 支持在类属性注入

containerBuilder.RegisterType<实现类>().As<抽象类>()
    .PropertiesAutowired(); //表示在创建对象的同时将对象的属性直接注入 

选择性属性注入

//1、创建自定义的特性用于标记需要属性注入
[AttributeUsage(AttributeTargets.Property)]//标识只能用于属性
public class MySelectorAttribute : Attribute{
    
}

//2、继承并实现 Autofac 的IPropertySelector 接口，用于过滤标记了属性注入的属性
public class MyPropertySelector : IPropertySelector
{
    public bool InjectProperty(PropertyInfo propertyInfo,object instance){
    	//在这里判断哪些属性是需要属性注入的
     	return propertyInfo.CustomAttributes.Any(c => c.AttributeType == type(MySelectorAttribute));   
    }    
}

//3、在实体的属性上将要属性注入的属性标上特性
public class MyEntity{
    public Object ob;
    
    [MyPropertySelector]//标记上属性注入的特性
    public string str;
    
    public string Say(){
        Console.WriteLine("hello world");
    }
}

2.8、方法注入

在创建了某个实例后，调用某个方法需要参数时，支持参数自动注入

containerBuilder.RegisterType<参数实现类>().As<参数抽象类>();
containerBuilder.RegisterType<实现类>().As<抽象类>()
    .OnActivated(active => {
        参数类型 参数 = activa.Context.Resolve<参数抽象>();  
        //指定需要方法注入的方法
        activa.Instance.方法(参数);
    }); 

2.9、单个抽象多个实现的处理方案

{
    containerBuilder.RegisterType<实现类A>().As<抽象类>();
    containerBuilder.RegisterType<实现类B>().As<抽象类>();

    IContainer container = containerBuilder.Build();
    抽象类 ob = container.Resolve<抽象类>(); //当上述这样注册的时候，获取到的单个实例是后面注册的 实现类B 
}

//如果要区分单个抽象的不同实现类，需要给定一个标识，在获取的时候根据这个标识获取
{
    containerBuilder.RegisterType<实现类A>().Keyed<抽象类>("标识名A");
	containerBuilder.RegisterType<实现类B>().As<抽象类>("标识名B"));
    IContainer container = containerBuilder.Build();
    //获取
    抽象类 obA = container.ResolveKeyed<抽象类>("标识名A");
    抽象类 obB = container.ResolveKeyed<抽象类>("标识名B");    
}

3、Autofac 依赖注册支持 AOP

3.1、依赖注册时设置 EnableClassIntercept 支持

• 在实现类中标记【切入者特性】Intercept,并且把AOP的方法定义为 virtual

//1、Nuget引入Castle.core
//2、继承切入接口 IInterceptor，实现切入者逻辑
public class MyIntercept : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        {
            //调用方法前执行的逻辑
        }
        invocation.Proceed();//运行调用的方法
        {
            //调用方法后执行的逻辑
        }

    }
}


//3、在实现类中标记【切入者特性】Intercept,并且把AOP的方法定义为 virtual
[Intercept(typeof(MyIntercept))]//标记切入者特性
public class TestClass 
{
    public virtual void doSomething()//要支持 AOP 的方法要标记为virtual
    {
        Console.WriteLine("doSomething");
    }
}

//4、在注册抽象和实现类时需要支持 AOP 扩展 EnableClassIntercept

3.2、依赖注册时设置 EnableInterfaceInterceptors 支持

• 在抽象类中标记【切入者特性】Intercept,只要实现这个接口方法，不管实现类是否标记 virtual 都可以支持 AOP

3.3、依赖支持 AOP 的应用

• 日志

• 缓存