C#中如何调用抽象类类型对象的子类实现？

你遇到的这个情况完全可以不用第二个switch语句，C#本身是支持多态特性的，问题出在没有充分利用面向对象的核心思想来设计代码。

核心思路：用多态替代类型判断 #

抽象类的核心作用之一就是定义统一的行为契约，让子类去实现具体逻辑。你只需要在抽象父类中定义好需要执行的方法，然后让每个子类各自实现这个方法，之后直接调用抽象类对象的方法即可，程序会自动执行对应子类的实现，根本不需要再通过switch判断类型。

具体代码示例 #

首先改造你的抽象父类，添加抽象方法（如果需要默认逻辑也可以用虚方法）：

public abstract class AbstractParentType
{
    // 假设notifications是子类需要用到的依赖，通过构造函数传入
    protected INotifications Notifications;

    public AbstractParentType(INotifications notifications)
    {
        Notifications = notifications;
    }

    // 定义抽象方法，约定子类必须实现的行为
    public abstract void HandleDiagram();
}

然后让你的子类T1、T2分别实现这个抽象方法：

public class T1 : AbstractParentType
{
    public T1(INotifications notifications) : base(notifications)
    {
    }

    public override void HandleDiagram()
    {
        // 这里写T1类型的具体处理逻辑
        Notifications.Send("处理类型1的图表");
    }
}

public class T2 : AbstractParentType
{
    public T2(INotifications notifications) : base(notifications)
    {
    }

    public override void HandleDiagram()
    {
        // 这里写T2类型的具体处理逻辑
        Notifications.Send("处理类型2的图表");
    }
}

最后是你的调用代码，创建实例后直接调用方法就行：

AbstractParentType wfp;
switch (qi.DIAGRAMTYPE)
{
    case 1:
        wfp = new T1(notifications);
        break;
    case 2:
        wfp = new T2(notifications);
        break;
    // 其他类型的case...
    default:
        throw new ArgumentException("不支持的图表类型");
}

// 直接调用，自动执行对应子类的实现，无需再判断类型
wfp.HandleDiagram();

进阶优化：用工厂模式封装实例创建 #

如果连第一个创建实例的switch都想简化，可以用工厂模式把创建逻辑封装起来，让主代码更干净：

public class DiagramProcessorFactory
{
    public static AbstractParentType CreateProcessor(int diagramType, INotifications notifications)
    {
        return diagramType switch
        {
            1 => new T1(notifications),
            2 => new T2(notifications),
            _ => throw new ArgumentOutOfRangeException(nameof(diagramType), "不支持的图表类型")
        };
    }
}

调用的时候就变成：

AbstractParentType wfp = DiagramProcessorFactory.CreateProcessor(qi.DIAGRAMTYPE, notifications);
wfp.HandleDiagram();

这样后续新增图表类型时，只需要添加新的子类，并在工厂类里加一个case即可，完全符合开闭原则。

总结一下：C#不仅支持这种行为，而且这正是面向对象编程中多态特性的典型应用场景，通过抽象契约+子类实现，就能彻底摆脱重复的类型判断switch。

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