C#反射与重载方法：模拟编译器匹配逻辑及类型最优匹配

要模拟这个逻辑，得严格遵循C#的重载决议规则：先筛选所有可匹配的方法，再从候选集中找出最具体的那个。具体实现分两步：

第一步：筛选候选方法集 #

先从类型中拿到所有名为Func的实例方法，再过滤出参数数量匹配、且参数类型能接受传入实例隐式转换的方法。
比如传入B实例时，Func(Base)、Func(A)、Func(IA)都符合要求，因为B可以隐式转成这三个类型。

代码示例：

var wrapperInstance = new Wrapper();
var param = new Wrapper.B();
// 获取所有私有实例方法里的Func重载
var methodCandidates = typeof(Wrapper)
    .GetMethods(BindingFlags.Instance | BindingFlags.NonPublic)
    .Where(m => m.Name == "Func" && m.GetParameters().Length == 1)
    .Where(m => {
        var paramType = m.GetParameters()[0].ParameterType;
        // 判断传入参数的类型是否能隐式转换为方法参数类型
        return paramType.IsAssignableFrom(param.GetType());
    })
    .ToList();

第二步：筛选最优方法 #

编译器判断“最具体”的核心规则是：如果方法X的参数类型S能隐式转成方法Y的参数类型T，但T不能转成S，那X比Y更优。如果多个方法之间没有这种优先级关系，就会出现歧义。

实现逻辑： #

遍历候选集，找出所有“没有其他方法比它更优”的方法：

List<MethodInfo> optimalMethods = new();
foreach (var candidate in methodCandidates)
{
    var candidateParamType = candidate.GetParameters()[0].ParameterType;
    bool isOptimal = true;
    foreach (var other in methodCandidates)
    {
        if (candidate == other) continue;
        var otherParamType = other.GetParameters()[0].ParameterType;
        // 检查other是否比当前candidate更优
        if (otherParamType.IsAssignableFrom(candidateParamType) 
            && !candidateParamType.IsAssignableFrom(otherParamType))
        {
            isOptimal = false;
            break;
        }
    }
    if (isOptimal)
    {
        optimalMethods.Add(candidate);
    }
}

// 处理结果
if (optimalMethods.Count == 1)
{
    // 找到唯一最优方法，执行调用
    optimalMethods[0].Invoke(wrapperInstance, new object[] { param });
}
else if (optimalMethods.Count > 1)
{
    // 对应CS0121的歧义错误
    throw new AmbiguousMatchException("方法调用存在歧义");
}
else
{
    throw new MissingMethodException("找不到匹配的方法");
}

这个逻辑和方法重载的参数匹配完全一致：找列表中最具体的类型——它能被指定类型隐式转换，且列表中没有其他类型比它更具体。

实现代码 #

public static Type FindMostMatchingType(Type targetType, List<Type> typeList)
{
    // 第一步：筛选所有能接受targetType隐式转换的类型
    var candidates = typeList.Where(t => t.IsAssignableFrom(targetType)).ToList();
    if (!candidates.Any())
        return null;

    // 第二步：找出所有无更优候选的类型
    List<Type> optimalTypes = new();
    foreach (var candidate in candidates)
    {
        bool isOptimal = true;
        foreach (var other in candidates)
        {
            if (candidate == other) continue;
            // 如果other比candidate更具体，就标记当前candidate不是最优
            if (other.IsAssignableFrom(candidate) && !candidate.IsAssignableFrom(other))
            {
                isOptimal = false;
                break;
            }
        }
        if (isOptimal)
        {
            optimalTypes.Add(candidate);
        }
    }

    // 处理结果
    if (optimalTypes.Count == 1)
        return optimalTypes[0];
    // 多个最优类型，抛出异常或返回null，按需处理
    throw new InvalidOperationException("存在多个匹配类型，无法确定最具体的一个");
}

// 使用示例
var typeList = new List<Type> { typeof(Wrapper.Base), typeof(Wrapper.A), typeof(Wrapper.IA) };
var targetType = typeof(Wrapper.B);
try
{
    var mostMatching = FindMostMatchingType(targetType, typeList);
    Console.WriteLine(mostMatching?.Name); // 无IA时输出A，有IA时抛出歧义异常
}
catch (InvalidOperationException ex)
{
    Console.WriteLine(ex.Message);
}

补充说明 #

• 以上逻辑只覆盖了隐式转换的基础场景，C#的重载决议还包含显式转换、泛型、参数数组等复杂情况，如果需要完整实现，得参考C#语言规范的重载决议章节扩展逻辑。
• 类和接口的歧义场景：当目标类型同时继承类和实现接口，且这两个类型都在候选集中时，因为类和接口无法互相转换，会直接出现歧义——这就是新增Func(IA)后报错的根本原因。

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