Question

Currently

I’m using Moq to create a handful of mock objects; thus far everything is working nicely. Currently to ‘assign’ a delegate using Moq I’m doing

var someMock = new Mock<ISomeInterface>();
someMock.Setup(x => x.DoSomething(It.IsAny<int>())).Returns(this.DoSomething)

Where this.DoSomething is a method accepting an int parameter; fundamentally it’s the same structure as x.DoSomething on the ISomeInterface.

Question

Is it possible to simply assign a delegate, without the neeed for specifying all of its parameters, i.e. not using It.IsAny<int>()? Ideally something like this:

var someMock = new Mock<ISomeInterface>();
someMock.Setup(x => x.DoSomething).Returns(this.DoSomething)

Answer 1

No, that’s not possible. That’s not a “shortcoming” of Moq – C# doesn’t support it.

Some background:

Let’s assume ISomeInterface is declared as follows:

public interface ISomeInterface
{
    void Foo(int a, int b);
}

That would mean that the parameter of the Setup method would have to be a Func<ISomeInterface, Action<int, int>>.
The problem now is that the Setup method would have to be defined in a generic way, because your method could have any type of parameters:

Setup<T1, T2>(Func<T, Action<T1, T2>> param)

T is the generic type from the Mock class, T1 and T2 are the parameters of the method.

Calling this method however will result in a compiler error:

The type arguments for method Mock.Setup<T1, T2>(System.Func<UserQuery.ISomeInterface,System.Action<T1,T2>>) cannot be inferred from the usage. Try specifying the type arguments explicitly.

To make it work, you would need to call it like this:

someMock.Setup<int, int>(x => x.DoSomething)

or like this:

someMock.Setup(x => (Action<int, int>)x.DoSomething);

In both cases, you would have to specify the type of the parameters, just as you do it now already.

As to why you get the compiler error:

x.DoSomething is a method group. There exists an implicit conversion to Action<int, int>.
However, for this implicit conversion to be executed, the compiler needs to know the types of T1 and T2. But those types can only be inferred after the conversion took place.
Those two steps depend on each other and that’s why it doesn’t work.