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 的应用
-
日志
-
缓存