Enterprise Library深入解析与灵活应用（9）：个人觉得比较严重的关于CachingCallHandler的Bug

微软EnterLib的Policy Injection Application Block（PIAB）是一个比较好用的轻量级的AOP框架，你可以通过创建自定义的CallHandler实现某些CrossCutting的逻辑，并以自定义特性或者配置的方式应用到目标方法上面。PIAB自身也提供了一系列的CallHandler，其中CachingCallHandler直接利用HttpRuntime的Cache实现了基于方法级别的缓存。但是，PIAB发布到现在，CachingCallHandler就一直存着一个问题：如果目标方法具有Out参数并且返回类型不是void，会抛出IndexOutOfRangeException，如果返回类型为void，out参数也不会被缓存。不知道微软对此作何考虑，反正我觉得这是一个不可原谅的Bug。（Source Code从这里下载）

一、问题重现

这个问题还还重现，为了比较我们先来看看正常情况下CachingCallHandler的表现。下面我定义了一个简单的接口:IMembershipService, 包含一个方法GetUserName根据传入的User ID返回User Name。MembershipService实现了该接口，为了方便大家确定方法执行的结果是否被缓存，我让每次执行都返回一个GUID。CachingCallHandler直接以自定义特性的方式应用到GetUserName方法上。

using System;
using System.Threading;
using Microsoft.Practices.EnterpriseLibrary.PolicyInjection;
namespace CachingCallHandler4OutParam
{
    public interface IMembershipService
    {
        string GetUserName(string userId);
    }

    public class MembershipService : IMembershipService
    {
        [CachingCallHandler]
        public string GetUserName(string userId)
        {
            return Guid.NewGuid().ToString();
        }
    }
}

现在，在Main方法中，编写如下的代码：通过PolicyInjection的Create<TType, TInterface>创建能够被PIAB截获的Proxy对象，并在一个无限循环中传入相同的参数调用GetUserName方法。从输出结果我们看到，返回的UserName都是相同的，从而证明了第一次执行的结果被成功缓存。

using System;
using System.Threading;
using Microsoft.Practices.EnterpriseLibrary.PolicyInjection;
namespace CachingCallHandler4OutParam
{
    class Program
    {
        static void Main(string[] args)
        {
            IMembershipService svc = PolicyInjection.Create<MembershipService, IMembershipService>();
            while(true)
            {
                Console.WriteLine(svc.GetUserName("007"));
                Thread.Sleep(1000);
            }
        }
    }
}

输出结果：

E1E8EA0F-7620-4879-BA5D-33356568336E
E1E8EA0F-7620-4879-BA5D-33356568336E
E1E8EA0F-7620-4879-BA5D-33356568336E
E1E8EA0F-7620-4879-BA5D-33356568336E
E1E8EA0F-7620-4879-BA5D-33356568336E
E1E8EA0F-7620-4879-BA5D-33356568336E

现在我们修改我们的程序：将GetUserName改成TryGetUserName，将UserName以输出参数的形式反悔，Bool类型的返回值表示UserId是否存在，相信大家都会认为这是一个很常见的API定义方式。

using System;
using System.Threading;
using Microsoft.Practices.EnterpriseLibrary.PolicyInjection;
using Microsoft.Practices.EnterpriseLibrary.PolicyInjection.CallHandlers;
namespace CachingCallHandler4OutParam
{
    class Program
    {
        static void Main(string[] args)
        {
            IMembershipService svc = PolicyInjection.Create<MembershipService, IMembershipService>();
            string userName;
            while (true)
            {
                svc.TryGetUserName("007", out userName);
                Console.WriteLine(userName);
                Thread.Sleep(1000);
            }
        }
    }

    public interface IMembershipService
    {
        bool TryGetUserName(string userId, out string userName);
    }

    public class MembershipService : IMembershipService
    {
        [CachingCallHandler]
        public bool TryGetUserName(string userId, out string userName)
        {
            userName = Guid.NewGuid().ToString();
            return true;
        }
    }
}

运行上面一段程序之后，会抛出如下一个IndexOutOfRangeException，从StatckTrace我们可以知道，该异常实际上是在将方法调用返回消息转换成相应的输出参数是出错导致的：

Stack Trace：

at System.Runtime.Remoting.Proxies.RealProxy.PropagateOutParameters(IMessage msg, Object[] outArgs, Object returnValue)
at System.Runtime.Remoting.Proxies.RealProxy.HandleReturnMessage(IMessage reqMsg, IMessage retMsg)
at System.Runtime.Remoting.Proxies.RealProxy.PrivateInvoke(MessageData& msgData, Int32 type)
at CachingCallHandler4OutParam.IMembershipService.TryGetUserName(String userId, String& userName)
at CachingCallHandler4OutParam.Program.Main(String[] args) in e:\EnterLib\CachingCallHandler4OutParam\CachingCallHandler4OutParam\Program.cs:line 15
at System.AppDomain._nExecuteAssembly(Assembly assembly, String[] args)
at System.AppDomain.ExecuteAssembly(String assemblyFile, Evidence assemblySecurity, String[] args)
at Microsoft.VisualStudio.HostingProcess.HostProc.RunUsersAssembly()
at System.Threading.ThreadHelper.ThreadStart_Context(Object state)
at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
at System.Threading.ThreadHelper.ThreadStart()

二、是什么导致异常的抛出？

我们现在通过CachingCallHandler的Invoke方法的实现，可以看出一些问题：该CallHander仅仅会缓存方法的返回值（this.AddToCache(key, return2.ReturnValue);），而不是缓存输出参数；由于仅仅只有返回值被缓存，所以最终创建的IMethodReturn不包含输出参数，从而导致返回的消息与参数列表不一致，导致异常的发生。

public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
{
    if (this.TargetMethodReturnsVoid(input))
    {
        return getNext()(input, getNext);
    }
    object[] inputs = new object[input.Inputs.Count];
    for (int i = 0; i < inputs.Length; i++)
    {
        inputs[i] = input.Inputs[i];
    }
    string key = this.keyGenerator.CreateCacheKey(input.MethodBase, inputs);
    object[] objArray2 = (object[])HttpRuntime.Cache.Get(key);
    if (objArray2 == null)
    {
        IMethodReturn return2 = getNext()(input, getNext);
        if (return2.Exception == null)
        {
            this.AddToCache(key, return2.ReturnValue);
        }
        return return2;
    }
    return input.CreateMethodReturn(objArray2[0], new object[] { input.Arguments });
}

三、问题如何解决？

现在我们来Fix这个Bug，让它支持输出参数并对输出参数和返回值一并缓存。为此，我首先创建了如下一个OutputParamter类表示输出参数，属性Value和Index分别表示参数值和在方法参数列表中的位置：

public class OutputParameter
{
    public object Value
    { get; private set; }

    public int Index
    { get; private set; }

    public OutputParameter(object value, int index)
    {
        this.Value = value;
        this.Index = index;
    }
}

然后将需要进行缓存的方法返回值和输出参数封装在一个单独的类中，我将它起名为InvocationResult. 两个属性ReturnValue和Outputs分别表示返回值和输出参数。StreamlineArguments方法结合传入的所以参数列表返回一个方法参数值的数组，该数组的元素顺序需要与方法的参数列表相匹配。

public class InvocationResult
{
    public object ReturnValue
    { get; private set; }

    public OutputParameter[] Outputs
    { get; set; }

    public InvocationResult(object returnValue, OutputParameter[] outputs)
    {
        Guard.ArgumentNotNull(returnValue, "returnValue");
        this.ReturnValue = returnValue;
        if (null == outputs)
        {
            this.Outputs = new OutputParameter[0];
        }
        else
        {
            this.Outputs = outputs;
        }
    }

    public bool TryGetParameterValue(int index, out object parameterValue)
    {
        parameterValue = null;
        var result = this.Outputs.Where(param => param.Index == index);
        if (result.Count() > 0)
        {
            parameterValue = result.ToArray()[0].Value;
            return true;
        }
        return false;
    }

    public object[] StreamlineArguments(IParameterCollection arguments)
    {
        var list = new List<object>();
        object paramValue;
        for (int i = 0; i < arguments.Count; i++)
        {
            if (this.TryGetParameterValue(i, out paramValue))
            {
                list.Add(paramValue);
            }
            else
            {
                list.Add(arguments[i]);
            }
        }

        return list.ToArray();
    }
}

然后在现有CachingCallHandler的基础上，添加如下两个辅助方法：AddToCache和GetInviocationResult，分别用于将InvocationResult对象加入缓存，以及根据IMethodInvocation和IMethodReturn对象创建InvocationResult对象。最后将类名改成FixedCachingCallHandler以示区别。

public class FixedCachingCallHandler : ICallHandler
{
    //其他成员
    private void AddToCache(string key, InvocationResult result)
    {
        HttpRuntime.Cache.Insert(key, result, null, Cache.NoAbsoluteExpiration, this.expirationTime, CacheItemPriority.Normal, null);
    }


    private InvocationResult GetInvocationResult(IMethodInvocation input, IMethodReturn methodReturn)
    {
        var outParms = new List<OutputParameter>();

        for (int i = 0; i < input.Arguments.Count; i++)
        {
            ParameterInfo paramInfo = input.Arguments.GetParameterInfo(i);
            if (paramInfo.IsOut)
            {
                OutputParameter param = new OutputParameter(input.Arguments[i], i);
                outParms.Add(param);
            }
        }

        return new InvocationResult(methodReturn.ReturnValue, outParms.ToArray());
    }

}

最后我们重写Invoke方法, 去处对返回类型void的过滤，并实现对基于InvocationResult对象的缓存和获取：

public class FixedCachingCallHandler : ICallHandler
{
    //其他成员
    public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
    {
        object[] inputs = new object[input.Inputs.Count];
        for (int i = 0; i < inputs.Length; i++)
        {
            inputs[i] = input.Inputs[i];
        }
        string key = this.keyGenerator.CreateCacheKey(input.MethodBase, inputs);
        InvocationResult result = (InvocationResult)HttpRuntime.Cache.Get(key);
        if (result == null)
        {
            IMethodReturn return2 = getNext()(input, getNext);
            if (return2.Exception == null)
            {
                this.AddToCache(key, this.GetInvocationResult(input, return2));
            }
            return return2;
        }
        return input.CreateMethodReturn(result.ReturnValue, result.StreamlineArguments(input.Arguments));

        return returnValue;
    }

    private InvocationResult GetInvocationResult(IMethodInvocation input, IMethodReturn methodReturn)
    {
        var outParms = new List<OutputParameter>();

        for (int i = 0; i < input.Arguments.Count; i++)
        {
            ParameterInfo paramInfo = input.Arguments.GetParameterInfo(i);
            if (paramInfo.IsOut)
            {
                OutputParameter param = new OutputParameter(input.Arguments[i], i);
                outParms.Add(param);
            }
        }

        return new InvocationResult(methodReturn.ReturnValue, outParms.ToArray());
    }
}

应用新的CachingCallHandler，你将会得到正确的结果：

4DD83AE8-070B-49df-9781-6F4673C85189
4DD83AE8-070B-49df-9781-6F4673C85189
4DD83AE8-070B-49df-9781-6F4673C85189
4DD83AE8-070B-49df-9781-6F4673C85189
4DD83AE8-070B-49df-9781-6F4673C85189

作者：Artech
出处：http://artech.cnblogs.com
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。