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一个新的代理类。当然有人会说拦截器不是能获取到目标方法的一些信息吗?通过这些信息来判断方法是否需要被拦截不就好了吗?这种想法就大错特错了!拦截器的初衷就是在目标方法上无侵入性地完成一些事,如果自身的代码就被一些逻辑性代码侵入,这还不如一开始就不要拦截器。那么这个时候怎么办呢?

    /// 
    /// 代理钩子
    /// 
    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。

Castle 学习 之 动态代理(2)_第1张图片
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(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:有错误欢迎指摘。

你可能感兴趣的:(Castle 学习 之 动态代理(2))