在Moq中分配out/ref参数

Question

是否可以使用 Moq（3.0+）分配 out/ref 参数？

我已经尝试过使用 Callback()，但是因为它基于泛型，所以 Action<> 不支持 ref 参数。我还想在 ref 参数的输入上加上一个约束（It.Is），尽管我可以在回调函数中实现这一点。

我知道 Rhino Mocks 支持这个功能，但我们的项目已经在使用 Moq 了。

- Richard Szalay

---

这个问答是关于 Moq 3 的。Moq 4.8 对于 by-ref 参数的支持有了很大的改进，从 It.IsAny<T>() 类似的匹配器 (ref It.Ref<T>.IsAny) 到支持通过自定义委托类型匹配方法签名来设置 .Callback() 和 .Returns()。同样支持受保护的方法。请参见例如下面 我的回答。 - stakx - no longer contributing

你可以在任何使用out参数的方法中使用out It.Ref<TValue>.IsAny。例如：moq.Setup(x => x.Method(out It.Ref<string>.IsAny).Returns(TValue); - MikBTC

Answer 1

对于'out'，下面的方法在我的情况下似乎可以工作。

public interface IService
{
    void DoSomething(out string a);
}

[TestMethod]
public void Test()
{
    var service = new Mock<IService>();
    var expectedValue = "value";
    service.Setup(s => s.DoSomething(out expectedValue));

    string actualValue;
    service.Object.DoSomething(out actualValue);
    Assert.AreEqual(expectedValue, actualValue);
}

我猜想Moq在调用Setup时会查看“expectedValue”的值并记住它。

至于ref，我也在寻找答案。

我发现以下快速入门指南很有用：https://github.com/Moq/moq4/wiki/Quickstart

- Craig Celeste

---

我认为我遇到的问题是在 Setup 方法中没有分配输出或引用参数的方法。 - Richard Szalay

当Mocked接口方法在不同的作用域中执行且具有其自己引用的输出变量时，这对我来说行不通（例如，在另一个类的方法内部执行）。以上给出的示例很方便，因为执行发生在与模拟设置相同的作用域中，但它太简单了，无法解决所有情况。在moq中，对于out/ref值的显式处理支持较弱（据某人说，在执行时处理）。 - John K

+1：这是一个有帮助的答案。但如果out参数类型是一个类而不是像字符串这样内置的类型 - 我不认为这会起作用。今天我尝试了一下。模拟对象模拟调用，并通过“out”参数返回空。 - azheglov

@azheglov 不，它可以使用任何类型的 out 参数。你确定你的 Setup 被正确匹配了吗？否则，如果你有一个松散的模拟对象，当没有相关的 Setup 时，它可能会使用默认行为。如果你想确保 Moq 不会因为决定没有匹配到 Setup 就回退到空实现，请使用 MockBehavior.Strict。 - Jeppe Stig Nielsen

@JohnK 不，它不依赖于这样的范围。用于创建表达式树的lambda箭头=>将__闭合__或__捕获__局部变量expectedValue。不会有作用域问题。Moq框架可以检查表达式树，并找到捕获变量的值。 - Jeppe Stig Nielsen

Answer 2

Moq版本4.8及更高版本对于按引用参数的支持有了很大的改进：

public interface IGobbler
{
    bool Gobble(ref int amount);
}

delegate void GobbleCallback(ref int amount);     // needed for Callback
delegate bool GobbleReturns(ref int amount);      // needed for Returns

var mock = new Mock<IGobbler>();
mock.Setup(m => m.Gobble(ref It.Ref<int>.IsAny))  // match any value passed by-ref
    .Callback(new GobbleCallback((ref int amount) =>
     {
         if (amount > 0)
         {
             Console.WriteLine("Gobbling...");
             amount -= 1;
         }
     }))
    .Returns(new GobbleReturns((ref int amount) => amount > 0));

int a = 5;
bool gobbleSomeMore = true;
while (gobbleSomeMore)
{
    gobbleSomeMore = mock.Object.Gobble(ref a);
}

相同的模式也适用于“out”参数。

“It.Ref.IsAny”也适用于C# 7的“in”参数（因为它们也是按引用传递的）。

- stakx - no longer contributing

---

这是解决方案，它让您将任何输入作为引用，就像对于非引用输入一样。这确实是一个非常好的改进支持。 - grathad

这个解决方案对于out参数无效，对吗？ - ATD

@ATD 部分正确。使用带有 out 参数的委托声明，并使用上述语法在回调中分配值。 - royalTS

需要翻译的内容：worth mentioning that if the function you're mocking has more arguments, then the callback signature should follow the same pattern (not just the ref/out parameter)值得一提的是，如果您要模拟的函数具有更多的参数，则回调签名应该遵循相同的模式（不仅限于ref/out参数）。 - Yoav Feuerstein

Answer 3

编辑: 在Moq 4.10中，现在可以直接将具有out或ref参数的委托传递给Callback函数：

mock
  .Setup(x=>x.Method(out d))
  .Callback(myDelegate)
  .Returns(...); 

你需要定义一个委托并实例化它：

...
.Callback(new MyDelegate((out decimal v)=>v=12m))
...

对于Moq 4.10之前的版本：

Avner Kashtan在他的博客中提供了一个扩展方法，允许从回调函数中设置输出参数：Moq、Callbacks和Out参数：一个特别棘手的边缘情况

这个解决方案既优雅又hacky。它的优雅之处在于提供了一种流畅的语法，感觉与其他Moq回调相得益彰。而它的hacky之处则在于依赖于通过反射调用一些内部的Moq API。

上面链接中提供的扩展方法没有编译通过，因此我提供了下面的编辑版本。您将需要为每个输入参数数量创建一个签名；我提供了0和1，但进一步扩展应该很简单:

public static class MoqExtensions
{
    public delegate void OutAction<TOut>(out TOut outVal);
    public delegate void OutAction<in T1,TOut>(T1 arg1, out TOut outVal);

    public static IReturnsThrows<TMock, TReturn> OutCallback<TMock, TReturn, TOut>(this ICallback<TMock, TReturn> mock, OutAction<TOut> action)
        where TMock : class
    {
        return OutCallbackInternal(mock, action);
    }

    public static IReturnsThrows<TMock, TReturn> OutCallback<TMock, TReturn, T1, TOut>(this ICallback<TMock, TReturn> mock, OutAction<T1, TOut> action)
        where TMock : class
    {
        return OutCallbackInternal(mock, action);
    }

    private static IReturnsThrows<TMock, TReturn> OutCallbackInternal<TMock, TReturn>(ICallback<TMock, TReturn> mock, object action)
        where TMock : class
    {
        mock.GetType()
            .Assembly.GetType("Moq.MethodCall")
            .InvokeMember("SetCallbackWithArguments", BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance, null, mock,
                new[] { action });
        return mock as IReturnsThrows<TMock, TReturn>;
    }
}

使用上述扩展方法，您可以测试具有输出参数的接口，例如：

public interface IParser
{
    bool TryParse(string token, out int value);
}

..使用以下Moq设置：

    [TestMethod]
    public void ParserTest()
    {
        Mock<IParser> parserMock = new Mock<IParser>();

        int outVal;
        parserMock
            .Setup(p => p.TryParse("6", out outVal))
            .OutCallback((string t, out int v) => v = 6)
            .Returns(true);

        int actualValue;
        bool ret = parserMock.Object.TryParse("6", out actualValue);

        Assert.IsTrue(ret);
        Assert.AreEqual(6, actualValue);
    }

编辑：为了支持void-return方法，你只需要添加新的重载方法：

public static ICallbackResult OutCallback<TOut>(this ICallback mock, OutAction<TOut> action)
{
    return OutCallbackInternal(mock, action);
}

public static ICallbackResult OutCallback<T1, TOut>(this ICallback mock, OutAction<T1, TOut> action)
{
    return OutCallbackInternal(mock, action);
}

private static ICallbackResult OutCallbackInternal(ICallback mock, object action)
{
    mock.GetType().Assembly.GetType("Moq.MethodCall")
        .InvokeMember("SetCallbackWithArguments", BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance, null, mock, new[] { action });
    return (ICallbackResult)mock;
}

这可以测试诸如以下接口：

public interface IValidationRule
{
    void Validate(string input, out string message);
}

[TestMethod]
public void ValidatorTest()
{
    Mock<IValidationRule> validatorMock = new Mock<IValidationRule>();

    string outMessage;
    validatorMock
        .Setup(v => v.Validate("input", out outMessage))
        .OutCallback((string i, out string m) => m  = "success");

    string actualMessage;
    validatorMock.Object.Validate("input", out actualMessage);

    Assert.AreEqual("success", actualMessage);
}

- Scott Wegner

---

@Wilbert，我已经更新了我的答案，添加了void返回函数的其他重载。 - Scott Wegner

我一直在我们的测试套件中使用这个解决方案，一直都很好用。但是自从更新到Moq 4.10之后，它就不再起作用了。 - Ristogod

看起来在这个提交中出现了问题 https://github.com/moq/moq4/commit/a605c281b812ab83d829e40018c37f00b6de52c6。也许现在有更好的方法？ - sparkplug

在 Moq4 中，MethodCall 现在是设置（Setup）的属性，因此上面 OutCallbackInternal 的实现会变成 var methodCall = mock.GetType().GetProperty("Setup").GetValue(mock); mock.GetType().Assembly.GetType("Moq.MethodCall").InvokeMember("SetCallbackResponse", BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance, null, methodCall, new[] { action });。 - mike mckechnie

@Ristogod，随着Moq 4.10的更新，你现在可以直接将具有out或ref参数的委托传递给Callback函数：mock.Setup(x=>x.Method(out d)).Callback(myDelegate).Returns(...);你需要定义一个委托并进行实例化：...Callback(new MyDelegate((out decimal v)=>v=12m))...; - esteuart

Answer 4

这是从 Moq 网站 获取的文档：

// out arguments
var outString = "ack";
// TryParse will return true, and the out argument will return "ack", lazy evaluated
mock.Setup(foo => foo.TryParse("ping", out outString)).Returns(true);


// ref arguments
var instance = new Bar();
// Only matches if the ref argument to the invocation is the same instance
mock.Setup(foo => foo.Submit(ref instance)).Returns(true);

- Kosau

---

这基本上与Parched的答案相同，并具有相同的限制，即无法根据输入更改输出值，也无法响应ref参数。 - Richard Szalay

@Richard Szalay，你可以这样做，但需要使用不同的设置和不同的“outString”参数。 - Sielu

Answer 5

在Billy Jakes的答案基础上，我创建了一个带有输出参数的完全动态的模拟方法。我将其发布在这里，以供任何发现它有用的人使用。

// Define a delegate with the params of the method that returns void.
delegate void methodDelegate(int x, out string output);

// Define a variable to store the return value.
bool returnValue;

// Mock the method: 
// Do all logic in .Callback and store the return value.
// Then return the return value in the .Returns
mockHighlighter.Setup(h => h.SomeMethod(It.IsAny<int>(), out It.Ref<int>.IsAny))
  .Callback(new methodDelegate((int x, out int output) =>
  {
    // do some logic to set the output and return value.
    output = ...
    returnValue = ...
  }))
  .Returns(() => returnValue);

- Martijn

---

非常好，非常感谢@Martijn。 - Lin Song Yang

Answer 6

看起来这个功能无法直接实现。似乎有人尝试过解决方案。

可以查看这个论坛帖子： http://code.google.com/p/moq/issues/detail?id=176

还可以看看这个问题： Verify value of reference parameter with Moq

- Gishu

---

感谢确认。我在搜索中实际上已经找到了这两个链接，但是我也注意到Moq将其之一的功能列为“支持ref/out参数”，所以我想要确定一下。 - Richard Szalay

Answer 7

在VS2022中，您可以简单地执行以下操作：

foo.Setup(e => e.TryGetValue(out It.Ref<ExampleType>.IsAny))
    .Returns((ref ExampleType exampleType) => {
        exampleType = new ExampleType();
        return true;
})

- Red Riding Hood

---

最简明扼要的答案。 - Alex

这对于out参数也适用，并且不需要显式的委托定义！ - undefined

Answer 8

我相信Scott的解决方案曾经起作用，

但这是一个不使用反射窥探私有API的好例子。现在已经失效了。

我能够使用委托来设置参数。

      delegate void MockOutDelegate(string s, out int value);

    public void SomeMethod()
    {
        ....

         int value;
         myMock.Setup(x => x.TryDoSomething(It.IsAny<string>(), out value))
            .Callback(new MockOutDelegate((string s, out int output) => output = userId))
            .Returns(true);
    }

- Billy Jake O'Connor

---

在这个上下文中，userId是什么意思？你模拟方法返回的就是这个值吗？ - devklick

Answer 9

为了在设置ref参数的同时返回一个值，这里有一段代码：

public static class MoqExtensions
{
    public static IReturnsResult<TMock> DelegateReturns<TMock, TReturn, T>(this IReturnsThrows<TMock, TReturn> mock, T func) where T : class
        where TMock : class
    {
        mock.GetType().Assembly.GetType("Moq.MethodCallReturn`2").MakeGenericType(typeof(TMock), typeof(TReturn))
            .InvokeMember("SetReturnDelegate", BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance, null, mock,
                new[] { func });
        return (IReturnsResult<TMock>)mock;
    }
}

然后声明一个与待模拟方法签名匹配的自己的委托，并提供自己的方法实现。

public delegate int MyMethodDelegate(int x, ref int y);

    [TestMethod]
    public void TestSomething()
    {
        //Arrange
        var mock = new Mock<ISomeInterface>();
        var y = 0;
        mock.Setup(m => m.MyMethod(It.IsAny<int>(), ref y))
        .DelegateReturns((MyMethodDelegate)((int x, ref int y)=>
         {
            y = 1;
            return 2;
         }));
    }

- Victor Mukherjee

---

当您无法访问将作为y传递的变量时，这是否有效？我有一个函数，它需要两个ref参数来设置DayOfWeek。我需要将这两个参数都设置为模拟存根中的特定日期，并且第三个参数是模拟数据库上下文。但是委托方法并没有被调用。看起来Moq会期望匹配传递给“ MyMethod”函数的本地y。这是您的示例的工作方式吗？谢谢。 - Greg Veres

Answer 10

今天下午我花了一个小时来解决这个问题，但是无论在哪里都找不到答案。后来我自己试着操作之后，终于找到了一个对我有效的解决方案。

string firstOutParam = "first out parameter string";
string secondOutParam = 100;
mock.SetupAllProperties();
mock.Setup(m=>m.Method(out firstOutParam, out secondOutParam)).Returns(value);

关键在于mock.SetupAllProperties();，它会为您存根所有属性。这可能不适用于每个测试用例场景，但如果您只关心获取YourMethod的return value，那么这将很好地发挥作用。

- maxshuty