Castle 学习 之 动态代理（2）

接着上次的学习。

        public virtual string GetUser(string name)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                return "Stranger";
            }
            return string.Format("Hello {0}",name);
        }

        public virtual string SelectUser(string name)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                return "Stranger";
            }
            return string.Format("Hello {0}", name);
        }

        public virtual string GetAccount(string name)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                return "Stranger";
            }
            return string.Format("Hello {0}", name);
        }

假如我们的代理类有三个需要拦截的方法，其中一个不需要被拦截（在某种情况下，但是在其他时候需要被拦截，所以还是需要写成虚方法），另外两个需要被不同的拦截器拦截。上次创建代理类时，目标方法会被所有的拦截器拦截，而我们又不能调用一个方法就重新New一个新的代理类。当然有人会说拦截器不是能获取到目标方法的一些信息吗？通过这些信息来判断方法是否需要被拦截不就好了吗？这种想法就大错特错了！拦截器的初衷就是在目标方法上无侵入性地完成一些事，如果自身的代码就被一些逻辑性代码侵入，这还不如一开始就不要拦截器。那么这个时候怎么办呢？

    /// <summary>
    /// 代理钩子
    /// </summary>
    public class ProxyGenerationHook : IProxyGenerationHook
    {
        //调用生成过程来通知整个过程已经完成
        public void MethodsInspected()
        {
            //throw new NotImplementedException();
        }

        //调用的生成过程通知成员没有标记为虚拟。
        public void NonProxyableMemberNotification(Type type, MemberInfo memberInfo)
        {
            //throw new NotImplementedException();
        }
        //通过生成过程调用来确定指定的方法应被代理。返回给定方法是否需要被代理
        public bool ShouldInterceptMethod(Type type, MethodInfo methodInfo)
        {
            return methodInfo.Name.Contains("User");
        }
    }

 public class InterceptorSelector : IInterceptorSelector
    {
        //选择要拦截调用的方法拦截器。
        public IInterceptor[] SelectInterceptors(Type type, MethodInfo method, IInterceptor[] interceptors)
        {
            if(method.Name.Contains("Get"))
            {
                return interceptors.Where(i=>i is AccountInterceptor).ToArray();
            }
            if (method.Name.Contains("Select"))
            {
                return interceptors.Where(i => i is LogInterceptor).ToArray();
            }
            return interceptors;
        }
    }

代理钩子决定了目标方法是否可以被拦截，而拦截选择器则决定了目标方法可以被哪些拦截器拦截。我们的CreateClassProxy的某个重载接受这样一个参数ProxyGenerationOptions。

Paste_Image.png

有了这些东西，开始烦恼的问题就迎仍而解啦。

 // GET: Account
        public ActionResult Index(string name)
        {
            var options = new ProxyGenerationOptions() {Selector= new InterceptorSelector(),Hook= new ProxyGenerationHook()}; 

            var proxy = new ProxyGenerator(); //提供类和接口的代理对象
            var interceptor =new AccountInterceptor();  //拦截器
            var logInterceptor = new LogInterceptor();
            var accountService = proxy.CreateClassProxy<AccountService>(options,interceptor, logInterceptor);
            ViewBag.Msg = accountService.GetUser(name); //被AccountInterceptor拦截
            ViewBag.Msg = accountService.SelectUser(name); //被LogInterceptor拦截
            ViewBag.Msg = accountService.GetAccount(name); //不被拦截
            return View();
        }

---

最后的几个点：
Castle 动态代理的实现有多种不同的方式，这里学习的只是其中一种（ClassProxy）
每一个拦截器最好只做一件事，不要怕定义多个拦截器，单一职责（SRP）
使用代理钩子和拦截选择器时注意把握控制的力度，有时候又不能没有，但过犹不及
当程序需要创建许多动态代理时，可以使用单例来获取ProxyGenerator类

PS：有错误欢迎指摘。