C#使用Autofac实现控制反转IoC和面向切面编程AOP
Autofac是一个.net下非常优秀，性能非常好的IOC容器（.net下效率最高的容器），加上AOP简直是如虎添翼。Autofac的AOP是通过Castle（也是一个容器）项目的核心部分实现的，名为Autofac.Extras.DynamicProxy,顾名思义，其实现方式为动态代理。
使用方式比较简单，先新建一个控制台项目，然后在Nuget上搜索Autofac.Aop并安装，如下顺序：
或者通过命令安装：
Install-Package Autofac.Aop
安装成功之后会项目会增加几个个引用，如下图：
1. 创建拦截器
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; //先在Nuget上搜索Autofac.Aop安装 using Castle.DynamicProxy; namespace AutofacDEMO { /// <summary> /// 拦截器 需要实现 IInterceptor接口 Intercept方法 /// </summary> public class LogInterceptor : IInterceptor { /// <summary> /// 拦截方法 打印被拦截的方法执行前的名称、参数和方法执行后的 返回结果 /// </summary> /// <param name="invocation">包含被拦截方法的信息</param> public void Intercept(IInvocation invocation) { Console.WriteLine("方法执行前:拦截{0}类下的方法{1}的参数是{2}", invocation.InvocationTarget.GetType(), invocation.Method.Name, string.Join(", ", invocation.Arguments.Select(a => (a ?? "").ToString()).ToArray())); //在被拦截的方法执行完毕后 继续执行 invocation.Proceed(); Console.WriteLine("方法执行完毕，返回结果：{0}", invocation.ReturnValue); Console.WriteLine(); } } }
2. 创建拦截容器
var builder = new ContainerBuilder();
3. 注册拦截器到Autofac容器
拦截器必须注册到Aufofac容器中，可以通过拦截器类型或者命名注入，这两种方式会让使用拦截器的方法有所不同
// 命名注入 builder.Register(c => new LogInterceptor()).Named<IInterceptor>("log-calls"); //类型注入 builder.Register(c => new LogInterceptor());
//或者 builder.RegisterType<LogInterceptor>();
4. 启用拦截器
启用拦截器主要有两个方法：EnableInterfaceInterceptors()，EnableClassInterceptors()。
EnableInterfaceInterceptors方法会动态创建一个接口代理
EnableClassInterceptors方法会创建一个目标类的子类代理类，这里需要注意的是只会拦截虚方法，重写方法
注意：需要引用Autofac.Extras.DynamicProxy2才能使用上面两个方法
//启用类代理拦截 //方式一：给类型上加特性Attribute builder.RegisterType<Student>().EnableClassInterceptors(); //方式二：在注册类型到容器的时候动态注入拦截器(去掉类型上的特性Attribute) builder.RegisterType<Teacher>().InterceptedBy(typeof(LogInterceptor)).EnableClassInterceptors(); //启用接口代理拦截 //方式一：给类型上加特性Attribute builder.RegisterType<Man>().As<IPerson>().EnableInterfaceInterceptors(); //方式二：在注册类型到容器的时候动态注入拦截器(去掉类型上的特性Attribute) builder.RegisterType<Man>().As<IPerson>().InterceptedBy(typeof(LogInterceptor)).EnableInterfaceInterceptors();
5. 指明要拦截的类型
有两种方法：
第一种：给类型加上特性Attribute
第二种：在注册类型到容器的时候动态注入拦截器
//动态注入拦截器 builder.RegisterType<Student>().InterceptedBy(typeof(LogInterceptor)).EnableClassInterceptors();
6. 测试效果如下
第一种：类代理拦截
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using Autofac.Extras.DynamicProxy2; namespace AutofacDEMO { /// <summary> /// 继承接口，并实现方法，给类型加上特性Attribute /// </summary> [Intercept(typeof(LogInterceptor))] public class Student { public string Name; public Teacher Teacher; public Subject Subject; /// <summary> /// 必须是虚方法 /// </summary> public virtual void Say() { Console.WriteLine("你正在调用Say方法！学生姓名：" + Name); } } [Intercept(typeof(LogInterceptor))] public class Teacher { /// <summary> /// 必须是虚方法 /// </summary> public virtual void Show() { Console.WriteLine("I am Teacher's class !"); } } public class Subject { /// <summary> /// 必须是虚方法 /// </summary> public virtual void Show() { Console.WriteLine("I am Subject's class !" ); } } }
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using Autofac; using Autofac.Extras.DynamicProxy2; namespace AutofacDEMO { class Program { static void Main(string[] args) { //启用拦截器主要有两个方法：EnableInterfaceInterceptors()，EnableClassInterceptors() //EnableInterfaceInterceptors方法会动态创建一个接口代理 //EnableClassInterceptors方法会创建一个目标类的子类代理类，这里需要注意的是只会拦截虚方法，重写方法 //注意：需要引用Autofac.Extras.DynamicProxy2才能使用上面两个方法 #region 启用类代理拦截 //创建拦截容器 var builder = new ContainerBuilder(); //注册拦截器到容器 builder.RegisterType<LogInterceptor>(); //方式一：给类型上加特性Attribute builder.RegisterType<Student>().EnableClassInterceptors(); builder.RegisterType<Teacher>().EnableClassInterceptors(); //方式二：在注册类型到容器的时候动态注入拦截器(去掉类型上的特性Attribute) //builder.RegisterType<Teacher>().InterceptedBy(typeof(LogInterceptor)).EnableClassInterceptors(); //builder.RegisterType<Student>().InterceptedBy(typeof(LogInterceptor)).EnableClassInterceptors(); //属性注入 builder.Register(c => new Student { Teacher = c.Resolve<Teacher>(), Subject = new Subject(), Name = "张三" }); using (var container = builder.Build()) { //从容器获取对象 var Student = container.Resolve<Student>(); Student.Say(); Student.Subject.Show(); Student.Teacher.Show(); } Console.ReadLine(); #endregion } } }
第二种：接口代理拦截
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace AutofacDEMO { /// <summary> /// 定义一个接口 /// </summary> public interface IPerson { void Say(string Name); } }
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using Autofac.Extras.DynamicProxy2; namespace AutofacDEMO { /// <summary> /// 继承接口，并实现方法，给类型加上特性Attribute /// </summary> [Intercept(typeof(LogInterceptor))] public class Man: IPerson { public string Age; public void Say(string Name) { Console.WriteLine("男人调用Say方法！姓名：" + Name + "，年龄：" + Age); } } /// <summary> /// 继承接口，并实现方法，给类型加上特性Attribute /// </summary> [Intercept(typeof(LogInterceptor))] public class Woman : IPerson { public void Say(string Name) { Console.WriteLine("女人调用Say方法！姓名：" + Name); } } /// <summary> /// 管理类 /// </summary> public class PersonManager { IPerson _Person; /// <summary> /// 根据传入的类型动态创建对象 /// </summary> /// <param name="ds"></param> public PersonManager(IPerson Person) { _Person = Person; } public void Say(string Name) { _Person.Say(Name); } } }
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using Autofac; using Autofac.Extras.DynamicProxy2; namespace AutofacDEMO { class Program { static void Main(string[] args) { //启用拦截器主要有两个方法：EnableInterfaceInterceptors()，EnableClassInterceptors() //EnableInterfaceInterceptors方法会动态创建一个接口代理 //EnableClassInterceptors方法会创建一个目标类的子类代理类，这里需要注意的是只会拦截虚方法，重写方法 //注意：需要引用Autofac.Extras.DynamicProxy2才能使用上面两个方法 #region 启用接口代理拦截(推荐用这种方式) //创建拦截容器 var builder2 = new ContainerBuilder(); //注册拦截器到容器 builder2.RegisterType<LogInterceptor>(); //构造函数注入(只要调用者传入实现该接口的对象，就实现了对象创建，下面两种方式) builder2.RegisterType<PersonManager>(); //方式一：给类型上加特性Attribute //属性注入 builder2.Register<Man>(c => new Man { Age = "20" }).As<IPerson>().EnableInterfaceInterceptors(); //builder2.RegisterType<Man>().As<IPerson>().EnableInterfaceInterceptors(); builder2.RegisterType<Woman>().Named<IPerson>("Woman").EnableInterfaceInterceptors(); //方式二：在注册类型到容器的时候动态注入拦截器(去掉类型上的特性Attribute) //builder2.RegisterType<Man>().As<IPerson>().InterceptedBy(typeof(LogInterceptor)).EnableInterfaceInterceptors(); //builder2.RegisterType<Woman>().Named<IPerson>("Woman").InterceptedBy(typeof(LogInterceptor)).EnableInterfaceInterceptors(); using (var container = builder2.Build()) { //从容器获取对象 var Manager = container.Resolve<PersonManager>(); Manager.Say("管理员"); var Person = container.Resolve<IPerson>(); Person.Say("张三"); var Woman = container.ResolveNamed<IPerson>("Woman"); Woman.Say("王萌"); } Console.ReadLine(); #endregion } } }
Autofac三种生命周期：InstancePerLifetimeScope、SingleInstance、InstancePerDependency
InstancePerLifetimeScope：同一个Lifetime生成的对象是同一个实例
SingleInstance：单例模式，每次调用，都会使用同一个实例化的对象；每次都用同一个对象；
InstancePerDependency：默认模式，每次调用，都会重新实例化对象；每次请求都创建一个新的对象
//方式二：在注册类型到容器的时候动态注入拦截器(去掉类型上的特性Attribute) builder.RegisterType<Man>().As<IPerson>().InterceptedBy(typeof(LogInterceptor)).InstancePerLifetimeScope().EnableInterfaceInterceptors();
看下面运行结果图
1、InstancePerLifetimeScope
2、SingleInstance
3、InstancePerDependency
AsImplementedInterfaces() 是以接口方式进行注入,注入这些类的所有的公共接口作为服务（除了释放资源）
builder.RegisterAssemblyTypes 注册程序集中符合条件的类型
Assembly assembly = Assembly.Load(assemblyName); //Assembly assembly = this.GetType().GetTypeInfo().Assembly; builder.RegisterAssemblyTypes(assembly).Where(type => !type.IsInterface && !type.IsSealed && !type.IsAbstract && type.Name.EndsWith("BLL", StringComparison.OrdinalIgnoreCase)) .AsImplementedInterfaces() .InstancePerLifetimeScope() .EnableInterfaceInterceptors() .InterceptedBy(typeof(LogInterceptor));
每个RegisterAssemblyTypes()调用将仅应用一组规则 - 如果要注册多个不同组的组件，则需要多次调用RegisterAssemblyTypes()
