使用Moq创建全通用类代理Setup时抛出延迟绑定操作异常

你可以通过泛型扩展方法+动态表达式树反射实现全自动化的Mock包装，无需手动处理每个方法或值类型分支。核心思路是为目标接口的所有方法动态构建Setup和Returns/Callback表达式，通过反射适配Moq的泛型方法签名，彻底规避手动维护的繁琐。

完整实现代码 #

using System;
using System.Linq;
using System.Reflection;
using System.Linq.Expressions;
using Moq;

public static class MockExtensions
{
    public static Mock<T> WrapInstance<T>(this Mock<T> mock, T instance) where T : class
    {
        var interfaceType = typeof(T);
        // 获取接口所有公共实例方法（排除属性的get/set特殊方法，可按需调整）
        var methods = interfaceType.GetMethods(BindingFlags.Public | BindingFlags.Instance)
                                  .Where(m => !m.IsSpecialName);

        foreach (var method in methods)
        {
            SetupWrappedMethod(mock, instance, method);
        }

        return mock;
    }

    private static void SetupWrappedMethod<T>(Mock<T> mock, T instance, MethodInfo method) where T : class
    {
        // 1. 构建Setup表达式：x => x.Method(It.IsAny<Param1>(), It.IsAny<Param2>(), ...)
        var mockParam = Expression.Parameter(typeof(T), "x");
        var itIsAnyMethod = typeof(It).GetMethod(nameof(It.IsAny));
        var setupArgs = method.GetParameters()
                             .Select(p => Expression.Call(itIsAnyMethod.MakeGenericMethod(p.ParameterType)))
                             .ToArray();
        var methodCallExpr = Expression.Call(mockParam, method, setupArgs);

        // 创建对应类型的Lambda表达式（区分有无返回值）
        LambdaExpression setupLambda;
        if (method.ReturnType == typeof(void))
        {
            setupLambda = Expression.Lambda<Action<T>>(methodCallExpr, mockParam);
        }
        else
        {
            var funcType = typeof(Func<,>).MakeGenericMethod(typeof(T), method.ReturnType);
            setupLambda = (LambdaExpression)typeof(Expression)
                .GetMethod(nameof(Expression.Lambda), new[] { typeof(Expression), typeof(ParameterExpression[]) })
                .MakeGenericMethod(funcType)
                .Invoke(null, new object[] { methodCallExpr, new[] { mockParam } });
        }

        // 反射调用Mock.Setup方法
        var setupMethod = typeof(Mock<T>)
            .GetMethods()
            .First(m => m.Name == nameof(Mock<T>.Setup) && 
                        m.GetParameters()[0].ParameterType.GetGenericTypeDefinition() == typeof(Expression<>) &&
                        m.GetParameters()[0].ParameterType.GetGenericArguments()[0].GetGenericTypeDefinition() == 
                            (method.ReturnType == typeof(void) ? typeof(Action<>) : typeof(Func<,>)));

        if (method.ReturnType != typeof(void))
        {
            setupMethod = setupMethod.MakeGenericMethod(method.ReturnType);
        }
        var setupResult = setupMethod.Invoke(mock, new[] { setupLambda });

        // 2. 构建Returns/Callback表达式：(p0, p1...) => instance.Method(p0, p1...)
        var paramTypes = method.GetParameters().Select(p => p.ParameterType).ToArray();
        var returnParams = paramTypes.Select((t, i) => Expression.Parameter(t, $"p{i}")).ToArray();
        var instanceCallExpr = Expression.Call(Expression.Constant(instance), method, returnParams);

        LambdaExpression returnsLambda;
        MethodInfo returnsMethod;

        if (method.ReturnType == typeof(void))
        {
            // 无返回值方法使用Callback
            var actionType = GetActionType(paramTypes);
            returnsLambda = Expression.Lambda(actionType, instanceCallExpr, returnParams);
            returnsMethod = setupResult.GetType().GetMethod(nameof(ISetup<T>.Callback), new[] { actionType });
        }
        else
        {
            // 有返回值方法使用Returns
            var funcType = GetFuncType(paramTypes, method.ReturnType);
            returnsLambda = Expression.Lambda(funcType, instanceCallExpr, returnParams);
            returnsMethod = setupResult.GetType().GetMethod(nameof(ISetup<T, object>.Returns), new[] { funcType });
        }

        returnsMethod?.Invoke(setupResult, new[] { returnsLambda });
    }

    // 动态获取对应参数数量的Action类型（支持0-16个参数）
    private static Type GetActionType(Type[] paramTypes)
    {
        if (paramTypes.Length == 0) return typeof(Action);
        var typeName = $"System.Action`{paramTypes.Length}";
        return Type.GetType(typeName)?.MakeGenericType(paramTypes) ?? typeof(Action);
    }

    // 动态获取对应参数数量的Func类型（支持0-16个参数+返回值）
    private static Type GetFuncType(Type[] paramTypes, Type returnType)
    {
        var allTypes = paramTypes.Concat(new[] { returnType }).ToArray();
        if (allTypes.Length == 1) return typeof(Func<>).MakeGenericType(returnType);
        var typeName = $"System.Func`{allTypes.Length}";
        return Type.GetType(typeName)?.MakeGenericType(allTypes) ?? typeof(Func<object>);
    }
}

使用示例 #

// 创建真实实例
var realService = new SomeService();
// 创建Mock并自动包装真实实现
var mock = new Mock<ISomeService>().WrapInstance(realService);

// 调用Mock的方法，实际会执行真实实例的逻辑
mock.Object.Run(123);

// 依然可以使用Moq的验证功能
mock.Verify(x => x.Run(It.IsAny<int>()), Times.Once);

方案优势 #

1. 全自动化：无需手动为每个方法编写Setup和Returns，适配任意接口
2. 无值类型分支：通过动态构建对应返回类型的表达式，避免装箱转换，解决Moq的表达式解析异常
3. 兼容所有方法类型：自动区分有无返回值方法，支持多参数（0-16个，符合.NET委托限制）
4. 保留Moq功能：既可以复用真实实现的业务逻辑，又能使用Mock的验证、拦截等特性

注意事项 #

• 默认排除了属性的get/set方法，若需要包装属性，可修改methods筛选逻辑，添加对特殊方法的处理（调用SetupGet/SetupSet）
• 暂未处理泛型方法，若需要支持泛型方法，需在遍历方法时判断IsGenericMethodDefinition，并动态处理泛型参数
• 对于out/ref参数，需调整It.IsAny为It.Ref<T>.IsAny，可在构建setupArgs时判断参数的IsOut或IsByRef属性

内容的提问来源于stack exchange，提问作者Arthur