AOP面向切面编程

OOP（面向对象编程）：万物皆对象，通过对象之间的相互组合，组成一系列功能，再将一系列功能组合成模块，最后组成系统。每个类就像一个细胞一样，通过组合的方式最终成为人，即系统。
OOP的优点在于设计灵活、可扩展、可重用，缺点在于面向对象都是静态的，需求上的细微变动将会对系统引起较大的影响，无法解决类内部的变化。

AOP（面向切面编程）：是对OOP的补充，专门用来解决类内部的变化问题。能动态修改静态OOP模型，即在不破坏封装的类的前提下，为类增加一些公共逻辑，而非业务逻辑。例如：（1）异常检测；（2）添加缓存；（3）参数检查；（4）添加日志

AOP的实现：1.静态实现AOP；2.动态实现AOP。
1.通过装饰器模式实现静态AOP，AOP能在方法前后增加自定义方法。

    public class DecoratorAOP
    {
        public static void Show()
        {
            User user = new User()
            {
                Name = "Li Ming",
                Password = "24524354dfs"
            };
            IUserProcessor processor = new UserProcessor();
            processor.RegisterUser(user);
            Console.WriteLine("——————————————————————");

            processor = new UserProcessorDecorator(processor);
            processor.RegisterUser(user);
        }

        public interface IUserProcessor
        {
            void RegisterUser(User user);
        }
        public class UserProcessor : IUserProcessor
        {
            public void RegisterUser(User user)
            {
                Console.WriteLine("注册:Name为{0},PassWord为{1}", user.Name, user.Password);
            }
        }

        /// <summary>
        /// 使用装饰器模式提供AOP功能
        /// </summary>
        public class UserProcessorDecorator : IUserProcessor
        {
            private IUserProcessor _UserProcessor { get; set; }
            public UserProcessorDecorator(IUserProcessor userprocessor)
            {
                this._UserProcessor = userprocessor;
            }

            public void RegisterUser(User user)
            {
                BeforeProceed(user);
                this._UserProcessor.RegisterUser(user);
                AfterProceed(user);
            }

            /// <summary>
            /// 业务逻辑之前自己的逻辑
            /// </summary>
            /// <param name="user"></param>
            private void BeforeProceed(User user)
            {
                Console.WriteLine("方法执行前自己的逻辑");
            }
            /// <summary>
            /// 业务逻辑之后自己的逻辑
            /// </summary>
            /// <param name="user"></param>
            private void AfterProceed(User user)
            {
                Console.WriteLine("方法执行后自己的逻辑");
            }
        }

    }

2.通过代理模式实现静态AOP，AOP能在方法前后增加自定义方法。

    public class ProxyAOP
    {
        public static void Show()
        {
            User user = new User()
            {
                Name = "Li Ming",
                Password = "24524354dfs"
            };
            IUserProcessor processor = new UserProcessor();
            processor.RegisterUser(user);
            Console.WriteLine("——————————————————————");

            processor = new ProxyUserProcessor();
            processor.RegisterUser(user);
        }

        public interface IUserProcessor
        {
            void RegisterUser(User user);
        }
        public class UserProcessor : IUserProcessor
        {
            public void RegisterUser(User user)
            {
                Console.WriteLine("注册:Name为{0},PassWord为{1}", user.Name, user.Password);
            }
        }

        /// <summary>
        /// 代理模式去提供一个AOP功能
        /// </summary>
        public class ProxyUserProcessor : IUserProcessor
        {
            private IUserProcessor _UserProcessor = new UserProcessor();

            public void RegisterUser(User user)
            {
                BeforeProceed(user);
                this._UserProcessor.RegisterUser(user);
                AfterProceed(user);
            }

            /// <summary>
            /// 业务逻辑之前自己的逻辑
            /// </summary>
            /// <param name="user"></param>
            private void BeforeProceed(User user)
            {
                Console.WriteLine("方法执行前自己的逻辑");
            }
            /// <summary>
            /// 业务逻辑之后自己的逻辑
            /// </summary>
            /// <param name="user"></param>
            private void AfterProceed(User user)
            {
                Console.WriteLine("方法执行后自己的逻辑");
            }
        }

    }

3.通过.Net Remoting/RealProxy 实现动态AOP，该方法的缺陷在于业务类必须是继承自MarshalByRefObject类型

    public class RealProxyAOP
    {
        public static void Show()
        {
            User user = new User()
            {
                Name = "Li Ming",
                Password = "24524354dfs"
            };

            UserProcessor processor = new UserProcessor();
            processor.RegisterUser(user);

            Console.WriteLine("——————————————————————");
            UserProcessor userProcessor = TransparentProxy.Create<UserProcessor>();
            userProcessor.RegisterUser(user);
        }

        /// <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);
                
                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);
            }
            
            /// <summary>
            /// 业务逻辑之前自己的逻辑
            /// </summary>
            /// <param name="msg"></param>            
            public void BeforeProceede(IMessage msg)
            {
                Console.WriteLine("方法执行前自己的逻辑");
            }
            
             /// <summary>
            /// 业务逻辑之后自己的逻辑
            /// </summary>
            /// <param name="msg"></param>
            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 IUserProcessor
        {
            void RegisterUser(User user);
        }

        /// <summary>
        /// 必须继承自MarshalByRefObject父类，否则无法生成
        /// </summary>
        public class UserProcessor : MarshalByRefObject, IUserProcessor
        {
            public void RegisterUser(User user)
            {
                Console.WriteLine("注册:用户名称为{0} Password为{1}", user.Name, user.Password);
            }
        }

    }

4.通过Castle\DynamicProxy 实现动态AOP，缺点在于方法必须为虚方法

    public class CastleProxyAOP
    {
        public static void Show()
        {
            User user = new User()
            {
                Name = "Li Ming",
                Password = "24524354dfs"
            };
            ProxyGenerator generator = new ProxyGenerator();
            MyInterceptor interceptor = new MyInterceptor();
            UserProcessor userprocessor = generator.CreateClassProxy<UserProcessor>(interceptor);
            userprocessor.RegisterUser(user);
        }
        public interface IUserProcessor
        {
            void RegisterUser(User user);
        }

        public class UserProcessor : IUserProcessor
        {
            /// <summary>
            /// 必须带上virtual 否则无效~
            /// </summary>
            /// <param name="user"></param>
            public virtual void RegisterUser(User user)
            {
                Console.WriteLine("注册:Name为{0},PassWord为{1}", user.Name, user.Password);
            }
        }

        public class MyInterceptor : IInterceptor
        {
            public void Intercept(IInvocation invocation)
            {
                PreProceed(invocation);
                invocation.Proceed();
                PostProceed(invocation);
            }
            /// <summary>
            /// 业务逻辑之前自己的逻辑
            /// </summary>
            /// <param name="invocation"></param>
            public void PreProceed(IInvocation invocation)
            {
                Console.WriteLine("方法执行前自己的逻辑");
            }
            /// <summary>
            /// 业务逻辑之后自己的逻辑
            /// </summary>
            /// <param name="invocation"></param>
            public void PostProceed(IInvocation invocation)
            {
                Console.WriteLine("方法执行后自己的逻辑");
            }
        }
    }

5.使用EntLib\PIAB Unity 实现动态AOP。此方法为通常使用的方法，引用里添加Unity.Interception和Unity，Unity.Interception为Unity的扩展。

    public class LogBeforeBehavior : IInterceptionBehavior
    {
        public IEnumerable<Type> GetRequiredInterfaces()
        {
            return Type.EmptyTypes;
        }
        public IMethodReturn Invoke(IMethodInvocation input, GetNextInterceptionBehaviorDelegate getNext)
        {
            Console.WriteLine("LogBeforeBehavior");
            Console.WriteLine(input.MethodBase.Name);
            foreach (var item in input.Inputs)
            {
                Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(item));               
            }
            return getNext().Invoke(input, getNext);//在自己逻辑执行前添加日志记录
        }

        public bool WillExecute
        {
            get { return true; }
        }
    }
    
        public class LogAfterBehavior : IInterceptionBehavior
    {
        public IEnumerable<Type> GetRequiredInterfaces()
        {
            return Type.EmptyTypes;
        }

        public IMethodReturn Invoke(IMethodInvocation input, GetNextInterceptionBehaviorDelegate getNext)
        {
            IMethodReturn methodReturn = getNext()(input, getNext);//在自己逻辑执行后添加日志记录

            Console.WriteLine("LogAfterBehavior");
            Console.WriteLine(input.MethodBase.Name);
            foreach (var item in input.Inputs)
            {
                Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(item));
            }
            Console.WriteLine("LogAfterBehavior" + methodReturn.ReturnValue);
            return methodReturn;
        }

        public bool WillExecute
        {
            get { return true; }
        }
    }

    public class UnityAOP
    {
        public static void Show()
        {
            User user = new User()
            {
                Name = "Li Ming",
                Password = "24524354dfs"
            };
            {
                //配置UnityContainer
                IUnityContainer container = new UnityContainer();
                ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap();
                //获取配置文件
                fileMap.ExeConfigFilename = Path.Combine(AppDomain.CurrentDomain.BaseDirectory + "Config\\Unity.Config");
                Configuration configuration = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None);
                UnityConfigurationSection configSection = (UnityConfigurationSection)configuration.GetSection(UnityConfigurationSection.SectionName);
                configSection.Configure(container, "AOPContainer");
                
                IUserProcessor processor = container.Resolve<IUserProcessor>();
                var user1 = processor.GetUser(user);
            }
        }
    }