Callback cannot modify captured variable if it is passed to set up method as ref parameter

[stakx]

Stumbled upon the following while implementing #105.

The following test sets up a Callback for a method having a ref parameter. Inside that callback, it tries to modify a captured variable (named capturedVariable). It turns out that the modification only succeeds if the captured variable isn't the one passed by-ref to the mocked method:

public interface IFrobbler
{
    void Frobble(ref string arg);
}

[Theory]
[InlineData(false)] // passes
[InlineData(true)]  // fails
public void CallbackCanModifyCapturedVariable(bool passCapturedVariableByRefToMockedMethod)
{
    string valueThatTriggersCallback = "original";

    string capturedVariable = valueThatTriggersCallback;
    string someOtherVariable = valueThatTriggersCallback;

    var mock = new Mock<IFrobbler>();
    mock.Setup(f => f.Frobble(ref valueThatTriggersCallback))
        .Callback(() =>
        {
            capturedVariable = "changed";
        });

    if (passCapturedVariableByRefToMockedMethod)
    {
        mock.Object.Frobble(ref capturedVariable);
    }
    else
    {
        mock.Object.Frobble(ref someOtherVariable);
    }

    Assert.Equal("changed", capturedVariable);
}

I am not sure yet whether this qualifies as a bug, but at the very least this behaviour is somewhat unintuitive and puzzling from a user's perspective.

[stakx]

Yes, this probably classifies as a bug. Plain C# has no problem changing a captured variable if that variable is also passed to a method by-ref, so people will likely expect this to work in Moq, too:

[Fact] // passes
public static void CanModifyCapturedVariableEvenWhenPassedAsByRefArgument()
{
    int value = 0;
    ModifyAction action = (ref int arg) => ++arg;

    action.Invoke(ref value);

    Assert.Equal(1, value);
}

delegate void ModifyAction(ref int x);

[stakx]

Moq's behaviour here seems to be directly related to Castle DynamicProxy:

[Fact] // does not pass
public static void InterceptorCanModifyCapturedVariableIfPassedByRefToInterceptedMethod()
{
    int value = 0;
    var interceptor = new InterceptionAction(invocation =>
    {
        value = 1;
    });
    var generator = new ProxyGenerator();
    var proxy = generator.CreateInterfaceProxyWithoutTarget<IFoo>(interceptor);

    proxy.Do(ref value);

    Assert.Equal(1, value);
}

public class InterceptionAction : IInterceptor
{
    private Action<IInvocation> callback;

    public InterceptionAction(Action<IInvocation> callback)
    {
        this.callback = callback;
    }

    public void Intercept(IInvocation invocation)
    {
        this.callback?.Invoke(invocation);
    }
}

public interface IFoo
{
    void Do(ref int arg);
}

See also castleproject/Core#311.

[stakx]

We've decided over at castleproject/Core#316 that it's probably not a good idea for DynamicProxy to support this particular scenario, so Moq likewise won't allow it.