如何为基类实例提供外部子类特定方法，无需显式类型判断？

通常，当我们有一个基类和多个实现了相同方法签名的子类时，会采用如下实现方式：

abstract class BaseClass
{
    public abstract int GetValue();
}

class SubClass : BaseClass
{
    public override int GetValue() => 123;
}
// 其他子类...

class MyClass
{
    public void SomeMethod()
    {
        BaseClass o = ...; // 实例化某个子类对象
        var i = o.GetValue();
    }
}

但如果希望在子类外部实现子类特定逻辑（比如访问者模式的场景），直接用下面的写法行不通——因为这涉及隐式类型转换，必须明确知道o的具体类型才能调用对应的方法：

class MyClass
{
    public void SomeMethod()
    {
        BaseClass o = ...;
        int i = CalculateSomething(o); // 编译错误：无法将BaseClass转换为SubClass
    }

    private int CalculateSomething(SubClass o)
    {
        return 999;
    }
}

请问有没有无需显式检查类型的代码实现或设计方案？

1. 正确实现访问者模式 #

访问者模式的核心就是通过基类定义的接受方法，让子类主动触发访问者中对应自身类型的逻辑，完全避免显式类型检查。

实现示例： #

// 定义访问者接口，为每个子类声明处理方法
interface IBaseVisitor
{
    int Visit(SubClass sub);
    int Visit(AnotherSubClass anotherSub);
}

abstract class BaseClass
{
    public abstract int GetValue();
    // 抽象接受方法，子类必须实现
    public abstract int Accept(IBaseVisitor visitor);
}

class SubClass : BaseClass
{
    public override int GetValue() => 123;
    public override int Accept(IBaseVisitor visitor)
    {
        // 主动调用访问者针对SubClass的方法，this自动匹配类型
        return visitor.Visit(this);
    }
}

class AnotherSubClass : BaseClass
{
    public override int GetValue() => 456;
    public override int Accept(IBaseVisitor visitor)
    {
        return visitor.Visit(this);
    }
}

// 具体访问者，封装子类特定逻辑
class CalculationVisitor : IBaseVisitor
{
    public int Visit(SubClass sub)
    {
        return 999; // SubClass专属逻辑
    }

    public int Visit(AnotherSubClass anotherSub)
    {
        return 888; // AnotherSubClass专属逻辑
    }
}

// 使用场景
class MyClass
{
    public void SomeMethod()
    {
        BaseClass o = new SubClass();
        var visitor = new CalculationVisitor();
        int i = o.Accept(visitor); // 无需类型判断，自动匹配对应逻辑
    }
}

2. C# 模式匹配（Switch表达式） #

从C# 7.0开始支持的模式匹配，可以在switch中直接匹配类型，编译器会自动完成类型转换，代码层面无需手动写显式类型检查。

实现示例： #

class MyClass
{
    public void SomeMethod()
    {
        BaseClass o = ...;
        int i = CalculateSomething(o);
    }

    private int CalculateSomething(BaseClass o)
    {
        return o switch
        {
            SubClass sub => 999, // 匹配SubClass类型，自动赋值给sub变量
            AnotherSubClass anotherSub => 888,
            _ => throw new ArgumentOutOfRangeException(nameof(o)) // 处理未定义的子类
        };
    }
}

这种方式无需修改原有基类和子类结构，适合快速实现类型专属逻辑，是日常开发中比较常用的方案。

3. 动态绑定（dynamic关键字） #

利用C#的dynamic关键字，让运行时根据对象实际类型解析调用对应的方法，编译时不做类型校验，从而避免显式类型检查。但要注意，这种方式会丢失编译时类型安全，若没有对应类型的方法，运行时会抛出异常。

实现示例： #

class MyClass
{
    public void SomeMethod()
    {
        BaseClass o = ...;
        dynamic d = o;
        int i = CalculateSomething(d); // 运行时自动匹配对应类型的方法
    }

    private int CalculateSomething(SubClass o)
    {
        return 999;
    }

    private int CalculateSomething(AnotherSubClass o)
    {
        return 888;
    }
}

该方案适合快速原型开发，但不建议在大型项目中使用，因为缺少编译时校验，排查问题成本较高。

内容的提问来源于stack exchange，提问作者Mr. Boy