Extension methods to quickly ignore arguments without repeating It.IsAny<>()

MoqExtensions.cs

using System;
using System.Linq.Expressions;
using Moq.Language.Flow;

namespace Moq
{
    public static class MoqExtensions
    {
        public static ISetup<T, TResult> SetupIgnoreArgs<T, TResult>(this Mock<T> mock,
            Expression<Func<T, TResult>> expression)
            where T : class
        {
            expression = new MakeAnyVisitor().VisitAndConvert(
                expression, "SetupIgnoreArgs");

            return mock.Setup(expression);
        }

        public static ISetup<T> SetupIgnoreArgs<T>(this Mock<T> mock,
            Expression<Action<T>> expression)
            where T : class
        {
            expression = new MakeAnyVisitor().VisitAndConvert(
                expression, "SetupIgnoreArgs");

            return mock.Setup(expression);
        }

        public static void VerifyIgnoreArgs<T>(this Mock<T> mock,
            Expression<Action<T>> expression, Func<Times> times = null)
            where T : class
        {
            expression = new MakeAnyVisitor().VisitAndConvert(
                expression, "VerifyIgnoreArgs");

            mock.Verify(expression, times ?? Times.AtLeastOnce);
        }

        public static void VerifyIgnoreArgs<T, TResult>(this Mock<T> mock,
            Expression<Func<T, TResult>> expression, Func<Times> times = null)
            where T : class
        {
            expression = new MakeAnyVisitor().VisitAndConvert(
                expression, "VerifyIgnoreArgs");

            mock.Verify(expression, times ?? Times.AtLeastOnce);
        }

        private class MakeAnyVisitor : ExpressionVisitor
        {
            protected override Expression VisitConstant(ConstantExpression node)
            {
                if (node.Value != null)
                    return base.VisitConstant(node);

                var method = typeof(It)
                    .GetMethod("IsAny")
                    .MakeGenericMethod(node.Type);

                return Expression.Call(method);
            }
        }
    }
}

MoqExtensionsTests.cs

using System;
using System.Collections;
using System.Collections.Generic;
using Xunit;

namespace Moq
{
    public class MoqExtensionsTests
    {
        [Fact]
        public void SetupIgnoreArgs_action_should_ignore_arguments()
        {
            var mock = new Mock<IDummy>();
            mock
                .SetupIgnoreArgs(x => x
                    .Execute(null, null, null))
                .Verifiable();

            mock.Object.Execute("dummy input",
                new[] {"dummy value"},
                new Dictionary<string, object>
                {
                    {"dummy key", new object()},
                });

            mock.Verify();
        }

        [Fact]
        public void SetupIgnoreArgs_function_should_ignore_arguments()
        {
            var mock = new Mock<IDummy>();
            mock
                .SetupIgnoreArgs(x => x
                    .Get(null, null, null))
                .Verifiable();

            mock.Object.Get("dummy input",
                new[] {"dummy value"},
                new Dictionary<string, object>
                {
                    {"dummy key", new object()},
                });

            mock.Verify();
        }

        [Fact]
        public void VerifyIgnoreArgs_action_should_ignore_arguments()
        {
            var mock = new Mock<IDummy>();

            mock.Object.Execute("dummy input",
                new[] {"dummy value"},
                new Dictionary<string, object>
                {
                    {"dummy key", new object()},
                });

            mock.VerifyIgnoreArgs(x => x
                .Execute(null, null, null));
        }

        [Fact]
        public void VerifyIgnoreArgs_function_should_ignore_arguments()
        {
            var mock = new Mock<IDummy>();

            mock.Object.Get("dummy input",
                new[] {"dummy value"},
                new Dictionary<string, object>
                {
                    {"dummy key", new object()},
                });

            mock.VerifyIgnoreArgs(x => x
                .Get(null, null, null));
        }

        public interface IDummy
        {
            void Execute(string input, IList values,
                IDictionary<string, object> settings);

            string Get(string input, IList values,
                IDictionary<string, object> settings);
        }
    }
}