2

我几乎明白为什么会出现这个特殊问题（尽管如果你能找到时间，我非常欢迎外行的解释！），我肯定涉及到装箱/拆箱，我不会试图错误地解释..

以我目前对这种情况的了解（或缺乏了解），我不确定如何最好地继续解决它。

这是一个相当简化的控制台应用程序，显示了我的问题：

static void Main(string[] args)
{
    try
    {
        // succeeds
        IEnumerable<Expression<Func<TestCase1Impl, dynamic>>> results1 =
            typeof(ITestCase1).GetMethods().Select(m => buildDynamicExpression(new TestCase1Impl(), m));
        Console.WriteLine("{0} methods processed on ITestCase1", results1.Count().ToString());

        // succeeds
        IEnumerable<Expression<Func<TestCase2Impl, int>>> results2 =
            typeof(ITestCase2).GetMethods().Select(m => buildTypedExpression(new TestCase2Impl(), m));
        Console.WriteLine("{0} methods processed on ITestCase2", results2.Count().ToString());

        // fails
        IEnumerable<Expression<Func<TestCase2Impl, dynamic>>> results3 =
            typeof(ITestCase2).GetMethods().Select(m => buildDynamicExpression(new TestCase2Impl(), m));
        Console.WriteLine("{0} methods processed on ITestCase2", results3.Count().ToString());
    }
    catch (Exception ex)
    {
        Console.WriteLine("Failed: {0}", ex.ToString());
    }

    Console.ReadKey();
}

private static Expression<Func<T, dynamic>> buildDynamicExpression<T>(T arg, MethodInfo method)
{
    ParameterExpression param = Expression.Parameter(typeof(T));
    MethodCallExpression[] args = new MethodCallExpression[0]; // none of the methods shown take arguments
    return Expression.Lambda<Func<T, dynamic>>(Expression.Call(param, method, args), new ParameterExpression[] { param });
}

private static Expression<Func<T, int>> buildTypedExpression<T>(T arg, MethodInfo method)
{
    ParameterExpression param = Expression.Parameter(typeof(T));
    MethodCallExpression[] args = new MethodCallExpression[0]; // none of the methods shown take arguments
    return Expression.Lambda<Func<T, int>>(Expression.Call(param, method, args), new ParameterExpression[] { param });
}

public interface ITestCase1
{
    string Method1();

    List<int> Method2();

    Program Method3();
}

public interface ITestCase2
{
    int Method4();
}

private class TestCase1Impl : ITestCase1
{
    public string Method1()
    {
        throw new NotImplementedException();
    }

    public List<int> Method2()
    {
        throw new NotImplementedException();
    }

    public Program Method3()
    {
        throw new NotImplementedException();
    }
}

private class TestCase2Impl : ITestCase2
{
    public int Method4()
    {
        throw new NotImplementedException();
    }
}

以上将输出

3 methods processed on ITestCase1
1 methods processed on ITestCase2
Failed: System.ArgumentException: Expression of type 'System.Int32' cannot be used for return type 'System.Object' <irrelevant stack trace follows>

就像这些问题经常出现的情况一样，最好在陷入这个可怕的混乱之前检查一下你是从哪里开始的。

我正在使用起订量。我有一个通用接口，在我的应用程序中被其他接口广泛使用。我需要测试我的接口使用者首先调用公共接口上的特定方法，然后再调用各种接口上的任何方法（事后看来，这对我来说听起来是一个糟糕的设计，我可能会在稍后解决这个问题，但纯粹是出于学术原因，我想先解决这个问题）。

为此，我使用It.IsAny<T>()参数为接口上的每个方法动态生成表达式，然后我可以将其传递给mock.Setup(generatedExpression).Callback(doSomethingCommonHere).

很可能有一种更简单的方法可以做到这一点，而不是我的表情构建......？

但是，如果不是，我的问题是，修改表达式构建以允许值类型的最佳方法是什么？

4

1 回答 1

4

这不是特定于dynamic. 如果替换为 ，您将获得相同的dynamic结果object。您甚至可以为实现接口的自定义值类型获得它，并且您希望从Func<IImplementedInterface>.
这样做的原因是，当您想要返回 an 时int，object它必须被装箱 - 正如您正确猜到的那样。
用于装箱的表达式是Expression.Convert。将其添加到您的代码将修复异常：

private static Expression<Func<T, dynamic>> BuildDynamicExpression<T>(
    T arg,
    MethodInfo method)
{
    ParameterExpression param = Expression.Parameter(typeof(T));
    var methodCall = Expression.Call(param, method);
    var conversion = 
    return Expression.Lambda<Func<T, dynamic>>(
        Expression.Convert(methodCall, typeof(object)),
        new ParameterExpression[] { param });
}

顺便说一句：如您所见，我删除了args数组。没有必要。

要解决 Moq 的问题，我认为您需要稍微改变方法。
思路如下：

  • 使用被调用方法的确切返回类型创建一个表达式。
  • 让 DLR（动态语言运行时）找出表达式的类型。

在代码中：

IEnumerable<Expression> results =
    typeof(ITestCase2).GetMethods()
                      .Select(m => BuildDynamicExpression(
                                       new TestCase2Impl(), m));

BuildDynamicExpression看起来像这样：

private static Expression BuildDynamicExpression<T>(T arg, MethodInfo method)
{
    ParameterExpression param = Expression.Parameter(typeof(T));
    return Expression.Lambda(Expression.Call(param, method),
                             new ParameterExpression[] { param });
}

用法是这样的：

foreach(var expression in results)
{
    mock.Setup((dynamic)expression);
    // ...
}

这里重要的部分是在dynamic将表达式传递给 之前强制转换为Setup。

于 2013-04-22T14:15:51.757 回答