代理模式 实现aop

通过代理模式，实现aop

public class ProxyAop
    {
        public static void Show()
        {
            User user = new User()
            {
                Name = "jump",
                Password = "123123"
            };

            Console.WriteLine("原来只干注册的事情");
            IUserProcessor userProcessor = new UserProcessor();
            userProcessor.RegUser(user);

            Console.WriteLine("实现aop后，的代理模式实现:");
            userProcessor = new UserProcessorProxy();//装饰了一层
            userProcessor.RegUser(user);
        }
    }

    public class User
    {
        public string Name { get; set; }
        public string Password { get; set; }
    }

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

    /// <summary>
    /// 需要被代理的类【就是要被扩展功能的类】
    /// </summary>
    public class UserProcessor : IUserProcessor
    {
        public void RegUser(User user)
        {
            Console.WriteLine("注册用户:" + user.Name);
        }
    }

    /// <summary>
    /// 代理类【就是扩展功能的类】
    /// </summary>
    public class UserProcessorProxy : IUserProcessor
    {
        /// <summary>
        /// 直接实例化指定实现类
        /// </summary>
        private IUserProcessor _userProcessor = new UserProcessor();
        public void RegUser(User user)
        {
            Console.WriteLine("注册前，做点其他的吧");
            _userProcessor.RegUser(user);
            Console.WriteLine("注册成功，发个邮件吧");
        }
    }

那么通过代理模式和装饰者模式 实现的aop有什么区别，看着就是实例化要被扩展功能的类时不一样

这是代理模式（通过属性）：

    /// <summary>
    /// 代理类【就是扩展功能的类】
    /// </summary>
    public class UserProcessorProxy : IUserProcessor
    {
        /// <summary>
        /// 直接实例化指定实现类
        /// </summary>
        private IUserProcessor _userProcessor = new UserProcessor();//通过属性直接实例化
        public void RegUser(User user)
        {
            Console.WriteLine("注册前，做点其他的吧");
            _userProcessor.RegUser(user);
            Console.WriteLine("注册成功，发个邮件吧");
        }
    }

这是装饰着模式（通过构造函数）：

    /// <summary>
    /// 装饰器类【就是扩展功能的类】
    /// </summary>
    public class UserProcessorDirecotr : IUserProcessor
    {
        private IUserProcessor _userProcessor;
        public UserProcessorDirecotr(IUserProcessor userProcessor)//通过构造函数
        {
            this._userProcessor = userProcessor;
        }
        public void RegUser(User user)
        {
            Console.WriteLine("注册前，做点其他的吧");
            _userProcessor.RegUser(user);
            Console.WriteLine("注册成功，发个邮件吧");
        }
    }

除了实现上的区别，另一个就是应用场景的区别。

比如，装饰者模式，你可以给多个类装饰，实现aop。但是代理模式只能对指定类实现代理模式，因为它在实例化的时候，已经确定了要扩展的类。两者都能实现aop，只是应用场景不一样。