3.静态AOP实现-代理模式

通过代理模式实现在RegUser()方法本身业务前后加上一些自己的功能，如：BeforeProceed和AfterProceed，即不修改UserProcessor类又能增加新功能

1. 定义1个用户接口，里面有个注册用户方法

   public interface IUserProcessor
   {
               void RegUser(User user);
   }

2. 实现用户这个接口

   public class UserProcessor : IUserProcessor
   {
               public void RegUser(User user)
               {
                   Console.WriteLine("用户已注册。Name:{0},PassWord:{1}", user.Name, user.Password);
               }
   }

3. 代理模式去提供一个AOP功能

   /// <summary>
   /// 代理模式去提供一个AOP功能，既有继承，又有new对象
   /// </summary>
   public class ProxyUserProcessor: IUserProcessor//继承
   {
               private IUserProcessor _UserProcessor = new UserProcessor();//new对象
   
               public void RegUser(User user)
               {
                   BeforeProceed(user);//在你本身业务之前加入一些逻辑
   
                   this._UserProcessor.RegUser(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("方法执行后");
               }
   }

4. 调用

   public static void Show()
   {
               User user = new User()
               {
                   Name = "Eleven",
                   Password = "
               };
               IUserProcessor processor = new UserProcessor();
               processor.RegUser(user);
               Console.WriteLine("***************");
   
              processor = new ProxyUserProcessor();
              processor.RegUser(user);
   }

   总结：
   装饰器模式和代理模式很像
   代理模式是内置一个对象，装饰器模式是通过构造函数传入了一个对象
   侧重点不同，装饰器模式可以层层装饰