C#中解析函数重载时如何强制协变？派生类重载调用问题

以下是C#代码示例：

public class BaseClass { };

public class A : BaseClass
{
    public void Foo(){ Console.WriteLine("A"); }
};

public class B : BaseClass
{
    public void Bar(){ Console.WriteLine("B"); }
};


public static void SwitchThingy(BaseClass obj){
    Console.WriteLine("Default case");
}

public static void SwitchThingy(A obj){
    obj.Foo();
}

public static void Main()
{
    A a = new A();
    B b = new B();
    SwitchThingy(a);
    SwitchThingy(b);
}

这段代码的输出是：

A
Default case

但如果修改Main方法为：

public static void Main()
{
    A a = new A();
    B b = new B();

    List<BaseClass> myList = new List<BaseClass>();
    myList.Add(a);
    myList.Add(b);

    SwitchThingy(myList[0]);
    SwitchThingy(myList[1]);
}

输出就变成了：

Default case
Default case

原因是C#的重载解析是在编译时完成的：当从List<BaseClass>中取出元素时，编译时类型是BaseClass，编译器会直接匹配接收BaseClass参数的重载，不会考虑运行时的实际类型。

需要实现的目标是：将对象放入List<BaseClass>后，仍能自动调用对应派生类的SwitchThingy重载，同时满足两个条件：

• 避免在多个子类（A、B……）中编写重复样板代码
• 保持SwitchThingy的实现独立于类外部

方法1：使用动态类型（Dynamic） #

直接在调用SwitchThingy时将参数转为dynamic，让重载解析延迟到运行时，根据实际类型匹配对应的方法：

public static void Main()
{
    A a = new A();
    B b = new B();

    List<BaseClass> myList = new List<BaseClass>();
    myList.Add(a);
    myList.Add(b);

    SwitchThingy((dynamic)myList[0]);
    SwitchThingy((dynamic)myList[1]);
}

输出会回到：

A
Default case

优缺点：

• 优点：实现最简单，无需修改原有类结构，完全符合SwitchThingy独立于类外部的要求，子类也不需要任何额外代码。
• 缺点：失去编译时类型检查，若新增派生类但未添加对应SwitchThingy重载，运行时会抛出RuntimeBinderException，需要额外处理异常。

方法2：使用模式匹配（C# 7.0+） #

修改SwitchThingy的基类重载，在内部用模式匹配判断实际类型，调用对应逻辑：

public static void SwitchThingy(BaseClass obj)
{
    switch (obj)
    {
        case A aObj:
            aObj.Foo();
            break;
        case B bObj:
            bObj.Bar();
            break;
        default:
            Console.WriteLine("Default case");
            break;
    }
}

// 可移除原来的SwitchThingy(A obj)重载，统一用这个方法处理

调用时直接用基类类型即可：

public static void Main()
{
    A a = new A();
    B b = new B();

    List<BaseClass> myList = new List<BaseClass>();
    myList.Add(a);
    myList.Add(b);

    SwitchThingy(myList[0]);
    SwitchThingy(myList[1]);
}

输出同样是：

A
Default case

优缺点：

• 优点：保留编译时类型检查，新增派生类时如果忘记处理，可通过代码分析规则提醒；逻辑集中在一个方法里，便于维护。
• 缺点：每次新增派生类都需要修改SwitchThingy的switch分支，但这是集中管理的代价，且子类无需任何修改。

方法3：优化版访问者模式（适合复杂场景） #

如果子类数量较多且后续可能频繁扩展，可使用访问者模式，通过扩展方法避免子类编写样板代码：

首先定义访问者接口：

public interface IBaseClassVisitor
{
    void Visit(A obj);
    void Visit(B obj);
    void VisitDefault(BaseClass obj);
}

给BaseClass添加扩展方法实现Accept逻辑：

public static class BaseClassExtensions
{
    public static void Accept(this BaseClass obj, IBaseClassVisitor visitor)
    {
        switch (obj)
        {
            case A aObj:
                visitor.Visit(aObj);
                break;
            case B bObj:
                visitor.Visit(bObj);
                break;
            default:
                visitor.VisitDefault(obj);
                break;
        }
    }
}

实现SwitchThingyVisitor：

public class SwitchThingyVisitor : IBaseClassVisitor
{
    public void Visit(A obj)
    {
        obj.Foo();
    }

    public void Visit(B obj)
    {
        obj.Bar();
    }

    public void VisitDefault(BaseClass obj)
    {
        Console.WriteLine("Default case");
    }
}

最后调用：

public static void SwitchThingy(BaseClass obj)
{
    var visitor = new SwitchThingyVisitor();
    obj.Accept(visitor);
}

public static void Main()
{
    A a = new A();
    B b = new B();

    List<BaseClass> myList = new List<BaseClass>();
    myList.Add(a);
    myList.Add(b);

    SwitchThingy(myList[0]);
    SwitchThingy(myList[1]);
}

优缺点：

• 优点：符合开闭原则，新增派生类时只需修改访问者接口和扩展方法的switch分支，原有子类无需改动；逻辑分离，适合复杂业务场景。
• 缺点：比前两种方法复杂，适合需要频繁扩展且逻辑复杂的场景。

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