C# 面向切面编程 AOP

AOP(Aspect Oriented Programming) 面向切面编程

起源

引言  http://wayfarer.cnblogs.com/articles/241012.html

AOP技术基础  https://www.cnblogs.com/wayfarer/articles/241024.html

.Net平台AOP技术研究 https://www.cnblogs.com/wayfarer/articles/256909.html

AOP、POP、OOP 区别与联系

POP面向过程编程：符合逻辑思维，线性的处理问题-----无法应付复杂的系统

OOP面向对象编程：万物皆对象，对象交互完成功能，功能叠加成模块，模块组成系统，去搭建复杂的大型软件系统
 类----功能点---模块----系统
 类却是会变化的，增加日志/异常/权限/缓存/事务，只能修改类？
 GOF的23种设计模式，应对变化，核心套路是依赖抽象，细节就可以变化
 但是只能替换整个对象，但是没办法把一个类动态改变

AOP(Aspect):允许开发者动态的修改静态的OO模型，就像现实生活中对象在生命周期中会不断的改变自身。
AOP是一种编程思想，是OOP思想的补充

正是因为能够动态的扩展功能，所以在程序设计时就可以有以下好处：
1 聚焦核心业务逻辑，权限/异常/日志/缓存/事务， 通用功能可以通过AOP方式添加，程序设计简单，
2 功能动态扩展；集中管理,代码复用;规范化；

实现AOP的多种方式：
a 静态实现--装饰器/代理模式
b 动态实现--Remoting/Castle(Emit)
c 静态织入--PostSharp（收费）--扩展编译工具，生成的加入额外代码
d 依赖注入容器的AOP扩展(开发)
e MVC的Filter--特性标记，然后该方法执行前/后就多了逻辑  invoker调用中心--负责反射调用方法--检查特性--有则执行额外逻辑

A 装饰器模式实现静态代理-AOP 在方法前后增加自定义的方法

     public class Business : IBusiness
     {
         public virtual void DoSomething()
         {
             Console.WriteLine("DoSomething");
         }
     }
     public class BusinessAOP : IBusiness
     {
         public BusinessAOP(IBusiness IBusiness)
         {
             this._IBusiness = IBusiness;
         }
         private IBusiness _IBusiness;
         public override void DoSomething()
         {
             BeforeProceed();
             this._IBusiness.DoSomething();
             AfterProceed();
         }
         /// <summary>
         /// 业务逻辑之前
         /// </summary>
         /// <param name="user"></param>
         private void BeforeProceed()
         {
             Console.WriteLine("方法执行前");
         }
         /// <summary>
         /// 业务逻辑之后
         /// </summary>
         /// <param name="user"></param>
         private void AfterProceed()
         {
             Console.WriteLine("方法执行后");
         }
     }
     public interface IBusiness
     {
         void DoSomething();
     }
       //前端调用
       new BusinessAOP(new Business()).DoSomething();

B 代理模式实现静态代理-AOP 在方法前后增加自定义的方法

     public class Business : IBusiness
     {
         public void DoSomething()
         {
             Console.WriteLine("DoSomething");
         }
     }
     public class ProxyBusinessAOP : IBusiness
     {
         private IBusiness _IBusiness=new Business();
         public void DoSomething()
         {
             BeforeProceed();
             this._IBusiness.DoSomething();
             AfterProceed();
         }
         /// <summary>
         /// 业务逻辑之前
         /// </summary>
         /// <param name="user"></param>
         private void BeforeProceed()
         {
             Console.WriteLine("方法执行前");
         }
         /// <summary>
         /// 业务逻辑之后
         /// </summary>
         /// <param name="user"></param>
         private void AfterProceed()
         {
             Console.WriteLine("方法执行后");
         }
     }
     public interface IBusiness
     {
         void DoSomething();
     }
     //前端调用
     new ProxyBusinessAOP().DoSomething();

C 使用.Net Remoting/RealProxy 实现动态代理-局限在业务类必须是继承自MarshalByRefObject类型

     /// <summary>
     /// 必须继承自MarshalByRefObject父类，否则无法生成
     /// </summary>
     public class Business : MarshalByRefObject, IBusiness
     {
         public void DoSomething()
         {
             Console.WriteLine("DoSomething");
         }
     }
     /// <summary>
     /// 真实代理
     /// </summary>
     /// <typeparam name="T"></typeparam>
     public class MyRealProxy<T> : RealProxy
     {
         private T tTarget;
         public MyRealProxy(T target)
             : base(typeof(T))
         {
             this.tTarget = target;
         }

         public override IMessage Invoke(IMessage msg)
         {
             BeforeProceede(msg);//Log  try-catch

             IMethodCallMessage callMessage = (IMethodCallMessage)msg;
             object returnValue = callMessage.MethodBase.Invoke(this.tTarget, callMessage.Args);

             AfterProceede(msg);

             return new ReturnMessage(returnValue, new object[], , null, callMessage);
         }
         public void BeforeProceede(IMessage msg)
         {
             Console.WriteLine("方法执行前可以加入的逻辑");
         }
         public void AfterProceede(IMessage msg)
         {
             Console.WriteLine("方法执行后可以加入的逻辑");
         }
     }
     /// <summary>
     /// 透明代理
     /// </summary>
     public static class TransparentProxy
     {
         public static T Create<T>()
         {
             T instance = Activator.CreateInstance<T>();
             MyRealProxy<T> realProxy = new MyRealProxy<T>(instance);
             T transparentProxy = (T)realProxy.GetTransparentProxy();
             return transparentProxy;
         }
     }

     public interface IBusiness
     {
         void DoSomething();
     }
      //前端调用
      IBusiness iBusiness = new Business();
      iBusiness.DoSomething();
      Console.WriteLine("*********************");
      iBusiness = TransparentProxy.Create<Business>();
      iBusiness.DoSomething();

D 使用Castle\DynamicProxy 实现动态代理-方法必须是虚方法

     /// <summary>
     /// 使用Castle\DynamicProxy 实现动态代理
     /// 方法必须是虚方法
     /// </summary>
     public class CastleProxyAOP
     {
         public static void Show()
         {

             ProxyGenerator generator = new ProxyGenerator();
             MyInterceptor interceptor = new MyInterceptor();
             Business bus = generator.CreateClassProxy<Business>(interceptor);
             bus.DoSomething();
             Console.Read();
         }
         public interface IBusiness
         {
             void DoSomething();
         }

         public class Business : IBusiness
         {
             /// <summary>
             /// 必须带上virtual 否则无效~
             /// </summary>
             /// <param name="user"></param>
             public virtual void DoSomething()
             {
                 Console.WriteLine("DoSomething");
             }
         }

         public class MyInterceptor : IInterceptor
         {
             public void Intercept(IInvocation invocation)
             {
                 PreProceed(invocation);
                 invocation.Proceed();//就是调用原始业务方法
                 PostProceed(invocation);
             }
             public void PreProceed(IInvocation invocation)
             {
                 Console.WriteLine("方法执行前");
             }

             public void PostProceed(IInvocation invocation)
             {
                 Console.WriteLine("方法执行后");
             }
         }
     }