【代码设计】C# 实现 AOP 面向切面编程

    简单记录一下对AOP的认识，正文为3个部分
    一、AOP由来
    二、用DispatchProxy动态代理实现AOP
    三、通过特性标记，处理多种不同执行前、执行后的逻辑编排
 
一、AOP 由来

1.     IUserHelper userHelper = new CommonUserHelper();<br>    // commonUser.Create中存在 方法执行前、方法执行后的业务逻辑
2.     userHelper.Create("test0401_A");
5.     public interface IUserHelper
6.     {
7.         void Create(string name);
8.     }
10.     public class CommonUserHelper : IUserHelper
11.     {
12.         private void before()
13.         {
14.             Console.WriteLine("CommonUser before");
15.         }
17.         private void after()
18.         {
19.             Console.WriteLine("CommonUser after");
20.         }
22.         public void Create(string name)
23.         {
24.             before();
25.             Console.WriteLine($"  Common User : {name} Created !");
26.             after();
27.         }
28.     }
29. <br>

复制代码

CommonUserHelper 实现 IUserHelper 接口，假设希望在 Create方法执行前/后写入日志，那就存在这4种业务逻辑：
  ① 执行前写入日志，执行 Create
  ② 执行前写入日志，执行 Create，执行后写入日志
  ③ 执行 Create，执行后写入日志
  ④ 执行 Create
  单一个写日志的需求，就能有4种实现方式，极端情况下，是可以实现 4次 Create 方法；
  如果再加一个数据验证、IP验证、权限验证、异常处理、加入缓存..，那么实现的排列组合方式就更多了，
  无穷尽地加实现、替换类，这显然不是我们希望的。
AOP，Aspect Oriented Programing，是一种编程思维，是对这种缺陷的补充。
 
二、DispatchProxy （动态代理）实现AOP

1. using System.Reflection;
2. namespace Cjm.AOP
3. {
4.     public class TransformProxy
5.     {
6.         public static T GetDynamicProxy<T>(T instance)  
7.         {
8.             // DispatchProxy 是system.Reflection封装的类
9.             // 用以创建实现接口T的代理类CustomProxy的实例
10.             dynamic obj = DispatchProxy.Create<T, CustomProxy<T>>();
11.             obj.Instance = instance;
12.             return (T)obj;
13.         }
14.     }
16.     // DispatchProxy 是抽象类，
17.     // 实现该类的实例，实例方法执行是会跳转到 Invoke 方法中，
18.     // 以此达到不破坏实际执行的具体逻辑，而又可以在另外的地方实现执行前、执行后
19.     public class CustomProxy<T> : DispatchProxy
20.     {
21.         public T Instance { get; set; }
22.         protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
23.         {
24.             BeforeProcess();
25.             var relt = targetMethod?.Invoke(Instance, args);
26.             AfterProcess();
27.             return relt;
28.         }
30.         private void BeforeProcess()
31.         {
32.             Console.WriteLine($"This is BegoreProcess.");
33.         }
35.         private void AfterProcess()
36.         {
37.             Console.WriteLine($"This is AfterProcess.");
38.         }
39.     }
40. }
42.     // Main
43.     IUserHelper userHelper3 = new CommonUserHelper();
44.     userHelper3 = TransformProxy.GetDynamicProxy(userHelper3);
45.     userHelper3.Create("test0401_B");

复制代码

 
三、通过标记特性，处理多种不同的执行前/执行后方法

  此处借用Castle.Core的封装（可通过Nuget管理下载），
  通过实现 StandardInterceptor以重写 执行前/执行后 逻辑的封装方式，
  我们可以更加聚焦在如何处理多种 执行前/执行后 逻辑的编排上。

1. using Castle.DynamicProxy;
2. {
3.     ProxyGenerator proxy = new ProxyGenerator();
4.     CustomInterceptor customInterceptor = new CustomInterceptor();
5.     IUserHelper commonUserHelper = new CommonUserHelper();
6.     var userHelperProxy = proxy.CreateInterfaceProxyWithTarget<IUserHelper>(commonUserHelper, customInterceptor);
7.     userHelperProxy.Create("TEST0401_C");
8. }   

复制代码

1.     public class CustomInterceptor : StandardInterceptor
2.     {
3.         protected override void PreProceed(IInvocation invocation)
4.         {
5.             var method = invocation.Method;
6.             //if (method.IsDefined(typeof(LogBeforeAttribute), true))
7.             //{
8.             //    Console.WriteLine("LOG : CustomInterceptor.PreProceed");
9.             //}
11.             Action<IInvocation> action = (invocation) => base.PreProceed(invocation);
12.             // 获取该方法的所有继承BaseAOPAttribute的特性
13.             var attrs = method.GetCustomAttributes<BaseAOPAttribute>(true);<br>            // 对于 attrs 的排列顺序，可以在特性的实现中增加 int order 属性，在标记特性时写入排序编号
14.             foreach(var attr in attrs)
15.             {
16.                 // 这里是俄罗斯套娃
17.                 // 相当于 attr3.AOPAction(invocation, attr2.AOPAction(invocation, attr1.AOPAction(invocation, base.PreProceed(invocation))))
18.                 action = attr.AOPAction(invocation, action);
19.             }
20.             action.Invoke(invocation);
21.         }
23.         protected override void PerformProceed(IInvocation invocation)
24.         {
25.             Console.WriteLine("CustomInterceptor.PerformProceed");
26.             base.PerformProceed(invocation);
27.         }
29.         protected override void PostProceed(IInvocation invocation)
30.         {
31.             var method = invocation.Method;
32.             if (method.IsDefined(typeof(LogAfterAttribute), true))
33.             {
34.                 Console.WriteLine("LOG : CustomInterceptor.PostProceed");
35.             }
37.             base.PreProceed(invocation);
38.         }
39.     }

复制代码

1.     public class LogBeforeAttribute : Attribute {}
3.     public class LogAfterAttribute : Attribute {}
5.     public class CheckIPAttribute : BaseAOPAttribute
6.     {
7.         public override Action<IInvocation> AOPAction(IInvocation invocation, Action<IInvocation> action)
8.         {
9.             return (invocation) => {
10.                 Console.WriteLine("CheckIP ..");
11.                 action.Invoke(invocation); <br>            };
12.         }
13.     }
15.     public abstract class BaseAOPAttribute : Attribute
16.     {
17.         public abstract Action<IInvocation> AOPAction(IInvocation invocation, Action<IInvocation> action);
18.     }

复制代码

  通过给方法标记特性的方式，达到切面编程的目的（不影响原有实现，而增加实现执行前/执行后的逻辑）

1.     public interface IUserHelper
2.     {
3.         [LogBefore]
4.         [LogAfter]
5.         [CheckIP]
6.         void Create(string name);
8.         void CreateNoAttri();
9.     }

复制代码

 
============================================================
具体的AOP实现上需要考虑的问题多如牛毛，此处仅做简单的思路介绍。
以上主要参考自 B站 朝夕教育 2022 .Net Core AOP实现。
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！