05-《AspNetCore》-AOP

赫文予

AOP


面向切面编程AOP的对面向对象编程OOP的一个补充，它的特点是将系统逻辑和业务逻辑采取《非侵入式》分离。我们把系统封装成一个一个的切面（单一职责）进行顺意编排组合，插入（织入）到业务逻辑的执行过程（织入点）。
系统逻辑：异常处理，身份认证，授权，mvc，数据校验，事务处理。
业务逻辑：就是我们的业务Service。
切面：用于封装系统逻辑，比如身份认证filter，或者中间件
切入点：就是管道的位置。名词
织入：就是插入到管道的切入点的过程。动词
AOP的特点：
1.非侵入式
2.低耦合
3.代码服用
4.单一职责
5.可插拔
实现方式：
1.管道链，比如aspnetcore的中间件，mvc中的Filter
2.静态代理：思考如何加强一个List，使得在插入时打印日志？
3.动态代理：Emit
4.三种模式都需要通过一些技术进行串联，实现链式调用，构成管道。静态代理通过接口进行串联，动态代理通过反射进行串联。管道通过接口获取委托进行串联。委托本质也是接口。
代理：就是增强，代理对象必须尽量实现目标对象的功能，在此基础上进行加强。比如vpn，你的电脑的网络就是目标对象，vpn就是代理服务，代理服务起码得实现联网功能吧，然后对网络进行加强，访问到一些你的本机网络访问不到的东西。
掌握了AOP技术我们可以实现很多好处，做到非侵入式的增强业务逻辑。

1. //侵入式方案，把这个看懂。后面就是围绕这个开展，高出非侵入式
2. public static void A()
3. {
4.     Console.WriteLine("A:开始");
5.     B();//A，B的调用关系强行绑定，有侵入性
6.     Console.WriteLine("A:结束");
7. }
8. public static void B()
9. {
10.     Console.WriteLine("B:开始");
11.     C();
12.     Console.WriteLine("B:结束");
13. }
14. public static void C()
15. {
16.     Console.WriteLine("Hello World");
17. }
18. public static void Dobasic()
19. {
20.     A();
21. }

复制代码

静态代理

1.代理就是实现目标对象的标准（接口），在目标方法执行之前和之后进行逻辑织入的过程。代理的目的就是为了加强。代理不负责实现接口，一般通过target来实现接口。即代理除了可以增强之外还能简化接口的实现。
2.静态代理就是在代理之前就已经确定了代理关系。需要自己实现标准并编写代理类。代理类中的逻辑只能代理一些标准（实现多个接口）。无法代理所有标准。
3.静态代理可以实现不改变目标对象的源码的情况下进行加强，完成目标对象的能力，并且在此基础之上进行加强。
4.可以简化实现的成本，不改变业务代码，只需要编写额外的增强逻辑。不需要关系具体的业务实现。
5.代理和代理直接通过接口可以进行互相代理，链式调用，顺意编排组合，实现系统的多样化。

1. /// <summary>
2. /// 定义标准1
3. /// </summary>
4. public interface IPhoneService
5. {
6.     string Mobile { get; set; }
7.     string Message { get; set; }
8.     void Send();
9. }
10. //实现标准-不是代理模式
11. public class PhoneService : IPhoneService
12. {
13.     public string Mobile { get; set; }
14.     public string Message { get; set; }
16.     public PhoneService(string mobile, string message)
17.     {
18.         Mobile = mobile;
19.         Message = message;
20.     }
22.     public virtual void Send()
23.     {
24.         Console.WriteLine($"已发送短信：{Message}到{Mobile}");
25.     }
26. }
27. //代理模式：
28. //1.实现目标对象的标准
29. //2.依赖目标对象（被代理对象）
30. //3.业务织入
31. public class PhoneServiceProxy : IPhoneService//实现标准
32. {
33.     private readonly IPhoneService _target;
35.     public PhoneServiceProxy1(IPhoneService target)
36.     {
37.         _target = target;
38.     }
40.     public string Mobile { get => _target.Mobile; set => _target.Mobile = value; }
41.     public string Message { get => _target.Message; set => _target.Message = value; }
43.     /// <summary>
44.     /// 子类重写父类方法
45.     /// </summary>
46.     public void Send()
47.     {
48.         Console.WriteLine("Proxy1:已对手机号进行验证");
49.         _target.Send();
50.         Console.WriteLine("Proxy1:已确认对方已经收到");
51.     }
52. }

复制代码

1. /// <summary>
2. /// 定义标准1
3. /// </summary>
4. public interface IPhoneService
5. {
6.     string Mobile { get; set; }
7.     string Message { get; set; }
8.     void Send();
9. }
10. /// <summary>
11. /// 定义标准2
12. /// </summary>
13. public interface IEmailService
14. {
15.     string Email { get; set; }
16.     string Message { get; set; }
17.     void Send();
18. }
19. /// <summary>
20. /// 业务逻辑1
21. /// </summary>
22. public class PhoneService : IPhoneService
23. {
24.     public string Mobile { get; set; }
25.     public string Message { get; set; }
27.     public PhoneService(string mobile, string message)
28.     {
29.         Mobile = mobile;
30.         Message = message;
31.     }
33.     public virtual void Send()
34.     {
35.         Console.WriteLine($"已发送短信：{Message}到{Mobile}");
36.     }
37. }
38. /// <summary>
39. /// 业务逻辑2
40. /// </summary>
41. public class EmailService : IEmailService
42. {
43.     public string Email { get; set; }
44.     public string Message { get; set; }
46.     public EmailService(string email, string message)
47.     {
48.         Email = email;
49.         Message = message;
50.     }
52.     public virtual void Send()
53.     {
54.         Console.WriteLine($"已发送邮件：{Message}到{Email}");
55.     }
56. }
58. /// <summary>
59. /// 切面1：校验能力（系统逻辑）
60. /// taget方式
61. /// </summary>
62. public class PhoneServiceProxy1
63.     : IPhoneService//实现标准1
64. {
65.     private readonly IPhoneService _target;
67.     public PhoneServiceProxy1(IPhoneService target)
68.     {
69.         _target = target;
70.     }
72.     /// <summary>
73.     /// 子类重写父类方法
74.     /// </summary>
75.     public void Send()
76.     {
77.         Console.WriteLine("Proxy1:已对手机号进行验证");
78.         _target.Send();
79.         Console.WriteLine("Proxy1:已确认对方已经收到");
80.     }
81. }
82. /// <summary>
83. /// 切面2：加速能力（系统逻辑）
84. /// </summary>
85. public class PhoneServiceProxy2
86.    : IPhoneService//实现标准1
87. {
88.     private readonly IPhoneService _target;
90.     public PhoneServiceProxy2(IPhoneService target)
91.     {
92.         _target = target;
93.     }
95.     /// <summary>
96.     /// 子类重写父类方法
97.     /// </summary>
98.     public void Send()
99.     {
100.         Console.WriteLine("Proxy2:已开启加速通道");
101.         _target.Send();
102.         Console.WriteLine("Proxy2:已关闭加速通道");
103.     }
104. }
105. //test
106. public static void TestStaticProxy()
107. {
108.     //目标对象
109.     IPhoneService target = new PhoneService("10088", "你好啊！");
110.     //切面1：验证，对target进行代理
111.     IPhoneService proxy1 = new PhoneServiceProxy1(target);
112.     //切面2：加速，对proxy1进行代理
113.     IPhoneService proxy2 = new PhoneServiceProxy2(proxy1);
114.     //执行
115.     proxy2.Send();
116.     //思考如果要实现IEmailService标准，是不是要重写实现类了？
117. }

复制代码

动态代理

Castle.Core

动态代理和静态代理的区别就是，代理类由工具生成，需要在运行时确认代理类已经代理关系。代理类中的逻辑写到拦截器里面，可以进行复用。缺点是性能差。里面涉及到大量反射技术。
Castle.Core：原理就是通过子类继承父类或者实现父类标准，通过Castle.Core自动帮你生成代理类，通过一个叫拦截器的东西编写代理类要执行的业务逻辑。Castle.Core会帮你生成代理类，并将拦截器织入到代理类中。
动态代理通过invocation进行串联，本质是反射。

1. /// <summary>
2. /// 定义标准1
3. /// </summary>
4. public interface IPhoneService
5. {
6.     string Mobile { get; set; }
7.     string Message { get; set; }
8.     void Send();
9. }
10. /// <summary>
11. /// 定义标准2
12. /// </summary>
13. public interface IEmailService
14. {
15.     string Email { get; set; }
16.     string Message { get; set; }
17.     void Send();
18. }
19. /// <summary>
20. /// 业务逻辑1
21. /// </summary>
22. public class PhoneService : IPhoneService
23. {
24.     public string Mobile { get; set; }
25.     public string Message { get; set; }
27.     public PhoneService(string mobile, string message)
28.     {
29.         Mobile = mobile;
30.         Message = message;
31.     }
33.     public virtual void Send()
34.     {
35.         Console.WriteLine($"已发送短信：{Message}到{Mobile}");
36.     }
37. }
38. /// <summary>
39. /// 业务逻辑2
40. /// </summary>
41. public class EmailService : IEmailService
42. {
43.     public string Email { get; set; }
44.     public string Message { get; set; }
46.     public EmailService(string email, string message)
47.     {
48.         Email = email;
49.         Message = message;
50.     }
52.     public virtual void Send()
53.     {
54.         Console.WriteLine($"已发送邮件：{Message}到{Email}");
55.     }
56. }
57. /// <summary>
58. /// 代理1：任意标准
59. /// </summary>
60. public class ShareInterceptor1 : IInterceptor
61. {
62.     public void Intercept(IInvocation invocation)
63.     {
64.         Console.WriteLine("Proxy1:已对接收方进行验证");
65.         invocation.Proceed();//执行下一个拦截器或者目标方法
66.         Console.WriteLine("Proxy1:已确认对方已经收到");
67.     }
68. }
69. /// <summary>
70. /// 代理2：任意标准
71. /// </summary>
72. public class ShareInterceptor2 : IInterceptor
73. {
74.     public void Intercept(IInvocation invocation)
75.     {
76.         Console.WriteLine("Proxy2:已开启加速通道");
77.         invocation.Proceed();//执行下一个拦截器或者目标方法
78.         Console.WriteLine("Proxy2:已关闭加速通道");
79.     }
80. }
81. //通过Castel生成代理类
82. public static void TestDynamicProxy1()
83. {
84.     //创建代理生成器
85.     var generator = new ProxyGenerator();
86.     var target1 = new PhoneService("10088", "你好啊！");
87.     var target2 = new EmailService("1123@116.com", "你好啊！");
88.     var interceptor1 = new ShareInterceptor1();//代理1，拦截器1，不需要去实现指定的标准
89.     var interceptor2 = new ShareInterceptor2();//代理2，拦截器2，不需要去实现指定的标准
90.     //使用代理1和代理2去代理手机的标准
91.     IPhoneService dynamicProxy1 = generator.CreateInterfaceProxyWithTarget<IPhoneService>(target1, interceptor1, interceptor2);
92.     dynamicProxy1.Send();
93.     //代理邮件的标准
94.     IEmailService dynamicProxy2 = generator.CreateInterfaceProxyWithTarget<IEmailService>(target2, interceptor1, interceptor2);
95.     dynamicProxy2.Send();
96. }

复制代码

手写Castle.Core的代理类

思考：
generator创建的是什么类型的实列？显然不可能是已有的类型。因为它把拦截器织入进去了。而且没有修改我们的代码，站在面向对象的角度来看只能是实现了我们的接口，Emit动态实现了下面的代码
多个拦截器和目标对象（被代理者）通过Invocation进行串联。Invocation中的Arguments完成链式调用。
手动通过Invocation进行串联

1. //假设有三个拦截器
2. //第一个拦截器invocation1：Proxy=interceptor2,Method=Intercept,argument=invocation2
3. //第二个拦截器invocation2：Proxy=interceptor3,Method=Intercept,argument=invocation3
4. //第三个拦截器invocation2：Proxy=target,Method=method,argument=arguments
5. //手动实现
6. public IInvocation GetInvocation(Stack<IInterceptor> stack, object target, Method method, objuect arguments)
7. {
8.     var invocation1 = new Invocation()
9.     {
10.         Proxy = interceptor2,
11.         Method = typeof(IInterceptor).GetMethod(nameof(IInterceptor.Intercept)),
12.         Arguments = new object[]
13.         {
14.             new Invocation()
15.             {
16.                 Proxy = interceptor3,
17.                 Method = typeof(IInterceptor).GetMethod(nameof(IInterceptor.Intercept)),
18.                 Arguments = new object[]
19.                 {
20.                     new Invocation()
21.                     {
22.                         Proxy = target,
23.                         Method = method,
24.                         Arguments = arguments
25.                     }  
26.                 }
27.             }
28.         }
29.     }
30. }
32. //递归实现
33. public IInvocation GetInvocation(Stack<IInterceptor> stack, object target, Method method, objuect arguments)
34. {
35.     if(stack.Any())
36.     {
37.         var proxy = stack.Pop();
38.         return new Invocation()
39.         {
40.                   Proxy = proxy,
41.             Method = typeof(IInterceptor).GetMethod(nameof(IInterceptor.Intercept)),
42.             Agrumtns = GetInvocation(stack,method,argumtns)
43.         };
44.     }
45.     else
46.     {
47.         return new Invocation()
48.         {
49.                   Proxy = target,
50.             Method = method,
51.             Agrumtns = arguments
52.         };
53.     }
54. }

复制代码

1. //Castel.Core自动帮我们生成了下面这个类
2. public class CastelPhoneServiceProxy : IPhoneService
3. {
4.     private IPhoneService _taget;
5.     private IInterceptor[] _interceptors;
7.     public CastelPhoneServiceProxy(IPhoneService taget, IInterceptor[] interceptors)
8.     {
9.         _taget = taget;
10.         _interceptors = interceptors;
11.     }
13.     public string Mobile { get => _taget.Mobile; set => _taget.Mobile = value; }
14.     public string Message { get => _taget.Message; set => _taget.Message = value; }
16.     public void Send()
17.     {
18.         var stack = new Stack<IInterceptor>(_interceptors.Reverse());
19.         if (stack.Any())
20.         {
21.             var item = stack.Pop();
22.             var invocation = GetNextInvocation(stack);
23.             item.Intercept(invocation);
24.         }
25.         else
26.         {
27.             _taget.Send();
28.         }
29.     }
30.     /// <summary>
31.     /// 递归获取Invocaltion
32.     /// </summary>
33.     /// <param name="stack"></param>
34.     /// <returns></returns>
35.     private IInvocation GetNextInvocation(Stack<IInterceptor> stack)
36.     {
37.         if (stack.Any())
38.         {
39.             var next = stack.Pop();
40.             return new Invocaltion
41.             {
42.                 Arguments = new object[]
43.                 {
44.                     //递归
45.                     GetNextInvocation(stack)
46.                 },
47.                 Proxy = next,
48.                 Method = typeof(IInterceptor).GetMethod(nameof(IInterceptor.Intercept)) ?? throw new NullReferenceException()
49.             };
50.         }
51.         else
52.         {
53.             return new Invocaltion
54.             {
55.                 Arguments = new object[]
56.                 {
58.                 },
59.                 Proxy = _taget,
60.                 Method = _taget.GetType().GetMethod(nameof(IPhoneService.Send)) ?? throw new NullReferenceException()
61.             };
62.         }
63.     }
64. }
65. //实现一些castle.core的接口
66. public class Invocaltion : IInvocation
67. {
68.     public object[] Arguments { get; set; }
70.     public Type[] GenericArguments { get; set; }
72.     public object InvocationTarget { get; set; }
74.     public MethodInfo Method { get; set; }
76.     public MethodInfo MethodInvocationTarget { get; set; }
78.     public object Proxy { get; set; }
80.     public object ReturnValue { get; set; }
82.     public Type TargetType { get; set; }
84.     public IInvocationProceedInfo CaptureProceedInfo()
85.     {
86.         throw new NotImplementedException();
87.     }
89.     public object GetArgumentValue(int index)
90.     {
91.         throw new NotImplementedException();
92.     }
94.     public MethodInfo GetConcreteMethod()
95.     {
96.         throw new NotImplementedException();
97.     }
99.     public MethodInfo GetConcreteMethodInvocationTarget()
100.     {
101.         throw new NotImplementedException();
102.     }
104.     public void Proceed()
105.     {
106.         Method.Invoke(Proxy, Arguments);
107.     }
109.     public void SetArgumentValue(int index, object value)
110.     {
111.         throw new NotImplementedException();
112.     }
113. }

复制代码

EMIT实现

1. //链路器
2. public class EmitInvocation
3. {
4.     private object? proxy;
5.     private MethodInfo? method;
6.     private object[]? arguments;
7.     public EmitInvocation(object? proxy, MethodInfo? method, object[]? arguments)
8.     {
9.         this.proxy = proxy;
10.         this.method = method;
11.         this.arguments = arguments;
12.     }
14.     public void Proceed()
15.     {
16.         method?.Invoke(proxy, arguments);
17.     }
19. }
20. //拦截器
21. public interface IEmitInteceptor
22. {
23.     void Intercept(EmitInvocation invocation);
24. }
25. //实现拦截器1
26. public class EmitInteceptor1 : IEmitInteceptor
27. {
28.     public void Intercept(EmitInvocation invocation)
29.     {
30.         Console.WriteLine("prox1:start");
31.         invocation.Proceed();
32.         Console.WriteLine("prox1:end");
33.     }
34. }
35. //实现拦截器1
36. public class EmitInteceptor2 : IEmitInteceptor
37. {
38.     public void Intercept(EmitInvocation invocation)
39.     {
40.         Console.WriteLine("prox2:start");
41.         invocation.Proceed();
42.         Console.WriteLine("prox2:end");
43.     }
44. }
45. //该工具类帮助我们少写emit代码
46. public static class EmitProxyInvoker
47. {
48.     public static EmitInvocation GetNextInvocation(Stack<IEmitInteceptor> stack, MethodInfo method, object target, object[] arguments)
49.     {
50.         if (stack.Any())
51.         {
52.             var next = stack.Pop();
53.             arguments = new object[]
54.             {
55.                 //递归
56.                 GetNextInvocation(stack, method, target, arguments)
57.             };
58.             return new EmitInvocation(next, typeof(IEmitInteceptor).GetMethod(nameof(IEmitInteceptor.Intercept)), arguments);
59.         }
60.         else
61.         {
62.             return new EmitInvocation(target, method, arguments);
63.         }
64.     }
66.     public static void Invoke(IEmitInteceptor[] interceptors, MethodInfo method, object target, object[] arguments)
67.     {
68.         var stack = new Stack<IEmitInteceptor>(interceptors.Reverse());
69.         if (stack.Any())
70.         {
71.             var item = stack.Pop();
72.             var invocation = GetNextInvocation(stack, method, target, arguments);
73.             item.Intercept(invocation);
74.         }
75.         else
76.         {
77.             method.Invoke(target, arguments);
78.         }
79.     }
80. }
81. //业务接口
82. public interface IEmitService
83. {
84.     void Send();
85. }
86. //将来要生成的代理类
87. public class EmitServiceProxy : IEmitService
88. {
89.     private object _target;
90.     private IEmitInteceptor[] _inteceptors;
92.     public EmitService()
93.     {
95.     }
97.     public void Send()
98.     {
99.         var method = _target.GetType().GetMethod(nameof(EmitService.Send));
100.         var arguments = new object[] { };
101.         EmitProxyInvoker.Invoke(_inteceptors, method, _target, new object[] { });
102.     }
103. }
105. public static class EmitProxyGenerator
106. {
107.     static AssemblyBuilder _assemblyBuilder;
108.     static ModuleBuilder _moduleBuilder;
109.     static EmitProxyGenerator()
110.     {
111.         //创建一个程序集
112.         var assemblyName = new AssemblyName("DynamicProxies");
113.         _assemblyBuilder = AssemblyBuilder
114.             .DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
115.         //创建一个模块
116.         _moduleBuilder = _assemblyBuilder.DefineDynamicModule("Proxies");
117.     }
118.     public static TInterface Create<TInterface>(object target, params IEmitInteceptor[] inteceptor)
119.         where TInterface : class
120.     {
121.         
122.         #region 定义类型
123.         //定义一个class，如果这个类型已定义直接返回，缓存
124.         var typeName = $"{target.GetType().Name}EmitProxy";
125.         var typeBuilder = _moduleBuilder.DefineType(
126.             typeName,
127.             TypeAttributes.Public,typeof(object),
128.             new Type[]
129.             {
130.                 typeof(TInterface)
131.             });
132.         #endregion
134.         #region 定义字段
135.         //定义字段
136.         var targetFieldBuilder = typeBuilder.DefineField("target", typeof(object), FieldAttributes.Private);
137.         var inteceptorFieldBuilder = typeBuilder.DefineField("inteceptor", typeof(IEmitInteceptor[]), FieldAttributes.Private);
138.         #endregion
140.         #region 定义构造器
141.         //定义构造器
142.         var constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.ExplicitThis, new Type[]
143.         {
144.             typeof(object),
145.             typeof(IEmitInteceptor[])
146.         });
147.         //获取IL编辑器
148.         var generator = constructorBuilder.GetILGenerator();
149.         generator.Emit(OpCodes.Ldarg_0);//加载this
150.         generator.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes) ?? throw new InvalidOperationException());
151.         generator.Emit(OpCodes.Nop);
152.         generator.Emit(OpCodes.Nop);
153.         // this.age = age;
154.         generator.Emit(OpCodes.Ldarg_0);//加载this
155.         generator.Emit(OpCodes.Ldarg_1);//加载target参数
156.         generator.Emit(OpCodes.Stfld, targetFieldBuilder);//加载target字段
157.         // this.name = name;
158.         generator.Emit(OpCodes.Ldarg_0);//加载this
159.         generator.Emit(OpCodes.Ldarg_2);//加载inteceptor参数
160.         generator.Emit(OpCodes.Stfld, inteceptorFieldBuilder);//加载inteceptor字段
161.         generator.Emit(OpCodes.Ret);
163.         #endregion
165.         #region 实现接口
166.         var methods = typeof(TInterface).GetMethods();
167.         foreach (var item in methods)
168.         {
169.             var parameterTypes = item.GetParameters().Select(s => s.ParameterType).ToArray();
170.             var methodBuilder = typeBuilder.DefineMethod(item.Name,
171.                 MethodAttributes.Public| MethodAttributes.Final |MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.HideBySig,
172.                 CallingConventions.Standard|CallingConventions.HasThis,
173.                 item.ReturnType,
174.                 parameterTypes);
175.             var generator1 = methodBuilder.GetILGenerator();
176.             //init
177.             var methodInfoLocal = generator1.DeclareLocal(typeof(MethodInfo));
178.             var argumentLocal = generator1.DeclareLocal(typeof(object[]));
179.             generator1.Emit(OpCodes.Nop);
180.             generator1.Emit(OpCodes.Ldarg_0);
181.             generator1.Emit(OpCodes.Ldfld, targetFieldBuilder);
182.             generator1.Emit(OpCodes.Callvirt, typeof(Type).GetMethod(nameof(Type.GetType),Type.EmptyTypes));
183.             generator1.Emit(OpCodes.Ldstr, item.Name);
184.             generator1.Emit(OpCodes.Callvirt, typeof(Type).GetMethod(nameof(Type.GetMethod), new Type[] { typeof(string) }));
185.             generator1.Emit(OpCodes.Stloc, methodInfoLocal);
186.             generator1.Emit(OpCodes.Ldc_I4_0);
187.             generator1.Emit(OpCodes.Newarr, typeof(object));
188.             generator1.Emit(OpCodes.Stloc, argumentLocal);
189.             generator1.Emit(OpCodes.Ldarg_0);
190.             generator1.Emit(OpCodes.Ldfld, inteceptorFieldBuilder);
191.             generator1.Emit(OpCodes.Ldloc_0);
192.             generator1.Emit(OpCodes.Ldarg_0);
193.             generator1.Emit(OpCodes.Ldfld, targetFieldBuilder);
194.             generator1.Emit(OpCodes.Ldc_I4_0);
195.             generator1.Emit(OpCodes.Newarr, typeof(object));
196.             generator1.Emit(OpCodes.Call, typeof(EmitProxyInvoker).GetMethod(nameof(EmitProxyUtil.Invoke)));
197.             generator1.Emit(OpCodes.Nop);
198.             generator1.Emit(OpCodes.Ret);
199.         }
200.         #endregion
201.         //创建:这个type可以用一个线程安全的字典缓存起来，第二次需要这个代理类的时候，就不需要在生成一次emit代码了。
202.         var type = typeBuilder.CreateType() ?? throw new ArgumentException();
203.         var instance = Activator.CreateInstance(type, target, inteceptor);
204.         return (TInterface)instance;
205.     }
206. }

复制代码

容器支持

1. public class DbContext
2. {
3.    
4. }
6. public class AService
7. {
8.     public DbContext DbContext { get; }
9.    
10.     public AService(DbContext context)
11.     {
12.         DbContext = context;
13.     }
14. }
15. public static void Test()
16. {
17.     var services = new ServiceCollection();
18.     services.AddScoped<DbContext>();
19.     var generator = new ProxyGenerator();
20.     //泛型-不支持动态注入
21.     services.AddScoped(sp =>
22.     {
23.         //通过容器解析依赖
24.         var target = ActivatorUtilities.CreateInstance<AService>(sp);
25.         return generator.CreateClassProxyWithTarget(target);
26.     });
27.     //反射-可以扫描批量注入
28.     services.AddScoped(typeof(AService), sp =>
29.     {
30.         //通过容器解析依赖
31.         var target = ActivatorUtilities.CreateInstance(sp, typeof(AService));
32.         return generator.CreateClassProxyWithTarget(target);
33.     });
34. }

复制代码

管道方式

委托方式

1.通过委托构建管道

1. public delegate Task RequestDelegate(HttpContext context);
3. public class HttpContext
4. {
6. }
8. public class ApplicationBuilder
9. {
10.     private readonly List<Func<RequestDelegate, RequestDelegate>> _componen
12.     public void Use(Func<RequestDelegate, RequestDelegate> middleware)
13.     {
14.         _components.Add(middleware);
15.     }
17.     public void Use(Func<HttpContext, Func<Task>, Task> middleware)
18.     {
19.         _components.Add((next) =>
20.         {
21.             return async c =>
22.             {
23.                 await middleware(c, () => next(c));
24.             };
25.         });
26.     }
28.     public void Use(Func<HttpContext, RequestDelegate, Task> middleware)
29.     {
30.         _components.Add((next) =>
31.         {
32.             return async c =>
33.             {
34.                 await middleware(c, next);
35.             };
36.         });
37.     }
39.     public void Run(RequestDelegate handler)
40.     {
41.         _components.Add((next) =>
42.         {
43.             return async c =>
44.             {
45.                 await handler(c);
46.             };
47.         });
48.     }
49.     //构建管道
50.     public RequestDelegate Build()
51.     {
52.         RequestDelegate app = c =>
53.         {
54.             throw new InvalidOperationException("无效的管道");
55.         };
56.         for (int i = _components.Count - 1; i > -1; i--)
57.         {
58.             app = _components[i](app);
59.         }
60.         return app;
61.     }
62. }

复制代码

接口方式

2.通过接口构建管道
有点类型动态代理，动态代理是通过Invocation进行反射，而下面的方式是通过接口的方式。反射更加灵活，性能不行。

1. public interface IChain
2. {
3.     Task NextAsync();
4. }
5. public class FilterChain : IChain
6. {
7.     private readonly IFilter _filter;
8.     private readonly HttpContext _context;
9.     private readonly IChain _next;
10.     public FilterChain(IFilter filter, HttpContext context, IChain next)
11.     {
12.         _filter = filter;
13.         _context = context;
14.         _next = next;
15.     }
16.     public async Task NextAsync()
17.     {
18.         await _filter.InvokeAsync(_context, _next);
19.     }
20. }
21. public class ServletChain : IChain
22. {
23.     private readonly IServlet _servlet;
24.     private readonly HttpContext _context;
26.     public ServletChain(IServlet servlet, HttpContext context)
27.     {
28.         _servlet = servlet;
29.         _context = context;
30.     }
32.     public async Task NextAsync()
33.     {
34.         await _servlet.DoPostAsync(_context);
35.     }
36. }
37. public interface IFilter
38. {
39.     Task InvokeAsync(HttpContext context, IChain chain);
40. }
41. public class Filter1 : IFilter
42. {
43.     public async Task InvokeAsync(HttpContext context, IChain chain)
44.     {
45.         Console.WriteLine("身份认证开始");
46.         await chain.NextAsync();
47.         Console.WriteLine("身份认证结束");
48.     }
49. }
51. public class Filter2 : IFilter
52. {
53.     public async Task InvokeAsync(HttpContext context, IChain chain)
54.     {
55.         Console.WriteLine("授权认证开始");
56.         await chain.NextAsync();
57.         Console.WriteLine("授权认证结束");
58.     }
59. }
61. public interface IServlet
62. {
63.     Task DoPostAsync(HttpContext context);
64. }
66. public class HelloServlet : IServlet
67. {
68.     public Task DoPostAsync(HttpContext context)
69.     {
70.         Console.WriteLine("Hello World");
71.         return Task.CompletedTask;
72.     }
73. }
75. public class WebHost
76. {
77.     private readonly List<IFilter> _filters = new List<IFilter>();
79.     public void AddFilter(IFilter filter)
80.     {
81.         _filters.Add(filter);
82.     }
84.     public void Exeucte(HttpContext context, IServlet servlet)
85.     {
86.         //自行处理filter为空的情况,就是直接执行serlvet就好了
87.         var stack = new Stack<IFilter>(_filters);
88.         var filter = stack.Pop();
89.         var chain = GetFilterChain(context, servlet,stack);
90.         filter.InvokeAsync(context, chain);
91.     }
93.     private IChain GetFilterChain(HttpContext context, IServlet servlet, Stack<IFilter> filters)
94.     {
95.         if (filters.Any())
96.         {
97.             var filter = filters.Pop();
98.             var chain = GetFilterChain(context, servlet, filters);
99.             return new FilterChain(filter, context, chain);
100.         }
101.         else
102.         {
103.             return new ServletChain(servlet, context);
104.         }
105.     }
106. }

复制代码

AOP总结

1.代理分为静态代理和动态代理，静态代理需要自己编写代理类，动态代理由框架生成代理类。
2.代理和管道都需要通过接口（委托）进行链接，串联，形成链式调用。
3.动态代理慎用，因为涉及到反射技术，而且对异步支持不友好。
4.静态代理常用于加强已有类型，比如接口要求一个IList，我们已经拥有了一个list实列，我们需要在在list.Add方法时打印日志，此时我们可以不改变原有的list，通过静态代理实现IList接口来进行对原有的list加强。这个方法在更改框架的时候很有用。我们可以对原有的HttpContext，进行加强。

来源:https://www.cnblogs.com/chaeyeon/archive/2023/02/14/17119566.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！