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[0], 0, 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 使用CastleDynamicProxy 实现动态代理-方法必须是虚方法

    /// <summary>
    /// 使用CastleDynamicProxy 实现动态代理
    /// 方法必须是虚方法
    /// </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("方法执行后");
            }
        }
    }