如何实现C#中Func<>类型对象的指定参数固定替换功能？

你要做的是部分应用（Partial Application）——把多参数Func的某个输入固定为常量，生成参数更少的新Func。你的GetNewFunctionType已经正确计算出了新委托的类型，接下来核心是用表达式树（Expression Tree）动态构建新委托的逻辑，这是类型安全且性能最优的方案，下面是完整实现：

完整的SetParameter方法实现 #

using System.Linq.Expressions;

public object SetParameter<T>(object function, int index, T value)
{
    // 验证输入是泛型Func类型
    var funcType = function.GetType();
    if (!funcType.IsGenericType)
        throw new InvalidOperationException("输入必须是泛型Func委托");
    
    var genericDef = funcType.GetGenericTypeDefinition();
    // 检查是否是Func系列委托（排除Action等其他委托）
    if (!genericDef.FullName.StartsWith("System.Func`"))
        throw new ArgumentException("仅支持Func系列委托");
    
    var typeArgs = funcType.GetGenericArguments();
    // 验证索引合法性：Func的最后一个泛型参数是返回值，所以参数数量是typeArgs.Length-1
    if (index < 0 || index >= typeArgs.Length - 1)
        throw new ArgumentOutOfRangeException(nameof(index), "参数索引超出范围");
    
    // 获取原委托的Invoke方法
    var invokeMethod = funcType.GetMethod("Invoke")!;
    var invokeParams = invokeMethod.GetParameters();
    
    // 1. 创建新委托的参数表达式：移除指定索引的原参数
    var newParamExpressions = invokeParams
        .Where((_, i) => i != index)
        .Select(p => Expression.Parameter(p.ParameterType, p.Name))
        .ToList();
    
    // 2. 构建原委托的调用参数列表：替换指定索引为常量值，其余用新参数填充
    var callParams = new Expression[invokeParams.Length];
    int newParamIndex = 0;
    for (int i = 0; i < invokeParams.Length; i++)
    {
        if (i == index)
        {
            // 把指定位置替换为常量值表达式
            callParams[i] = Expression.Constant(value, typeof(T));
        }
        else
        {
            callParams[i] = newParamExpressions[newParamIndex++];
        }
    }
    
    // 3. 创建原委托的常量表达式（把传入的function作为常量）
    var funcConstant = Expression.Constant(function, funcType);
    
    // 4. 构建调用原委托Invoke方法的表达式
    var callExpression = Expression.Call(funcConstant, invokeMethod, callParams);
    
    // 5. 编译为新委托
    var newFuncType = GetNewFunctionType<T>(function, index, value);
    var newFunc = Expression.Lambda(newFuncType, callExpression, newParamExpressions).Compile();
    
    return newFunc;
}

// 你已实现的GetNewFunctionType方法（补充完整）
private Type GetNewFunctionType<T>(object originalFunction, int index, T value)
{
    Type genericType = originalFunction.GetType();
    if (genericType.IsGenericType)
    {
        var types = genericType.GetGenericArguments().ToList();
        types.RemoveAt(index);
        Type genericTypeDefinition = genericType.GetGenericTypeDefinition();
        return genericTypeDefinition.MakeGenericType(types.ToArray());
    }
    throw new InvalidOperationException($"{nameof(originalFunction)} must be a generic type");
}

测试你的示例场景 #

// 原Func
Func<int, string, string> originalFunc = (a, b) => a.ToString() + b;
object objFunc = originalFunc;

// 固定第0个参数为5
var newFunc = (Func<string, string>)SetParameter<int>(objFunc, 0, 5);

// 测试调用
Console.WriteLine(newFunc("test")); // 输出：5test

关键逻辑解释 #

1. 类型验证：先确认输入是泛型Func委托，避免传入Action或其他非Func类型。
2. 表达式树构建：
   • 生成新委托的参数列表：移除指定索引的参数，创建对应的表达式参数。
   • 构建原委托的调用参数：把指定位置替换为常量值，其余用新委托的参数填充。
   • 通过Expression.Call调用原委托的Invoke方法，再用Expression.Lambda编译成新委托。
3. 类型安全：利用表达式树的编译机制，确保生成的委托类型和GetNewFunctionType返回的类型完全匹配，避免类型转换错误。

边界情况处理 #

• 会检查index是否在合法范围内（不能超过原Func的参数数量-1，因为Func的最后一个泛型参数是返回值）。
• 仅支持Func系列委托，如果需要支持Action，可以修改类型检查逻辑，同时调整GetNewFunctionType的返回类型（Action的泛型参数都是输入，没有返回值）。

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