多态场景下如何访问特定实现类的专属成员？

嘿，这个问题我之前在项目里也碰到过，在多态场景下要访问子类的专属成员确实容易卡壳，给你几个实用的解决方案，各有优缺点，你可以根据自己的业务场景来选：

C# 7以后引入的模式匹配语法，能让类型判断和变量赋值一步到位，代码简洁又易读，是我平时处理这种场景的首选。

比如ConcreteConsumerA可以这么实现：

public class ConcreteConsumerA : IConsumer 
{
    public void Consume(Product product)
    {
        // 直接匹配类型并赋值给变量
        if (product is SpecificProductA specificA)
        {
            // 这里可以直接访问SpecificProductA的专属成员ParamA
            Console.WriteLine($"获取到SpecificProductA的专属参数：{specificA.ParamA}");
        }
        else
        {
            // 根据业务需求，要么抛出异常，要么做默认处理
            throw new ArgumentException("当前Consumer仅支持处理SpecificProductA类型");
        }
    }
}

如果你的Consumer需要处理多种Product子类，还可以用switch模式匹配，逻辑更清晰：

public void Consume(Product product)
{
    switch (product)
    {
        case SpecificProductA specificA:
            Console.WriteLine($"处理A类产品：{specificA.ParamA}");
            break;
        case SpecificProductB specificB:
            Console.WriteLine($"处理B类产品：{specificB.ParamB}");
            break;
        default:
            throw new NotSupportedException("不支持该类型的产品");
    }
}

如果你的系统里Product子类和Consumer都比较多，而且后续还会频繁新增类型，那访问者模式会更优雅，能符合开闭原则，减少后续的代码改动。

首先得改造一下你的Product类，添加一个Accept方法来接收访问者：

public abstract class Product 
{ 
    public int BaseParam {get;set;}
    // 定义Accept方法，让子类实现自己的访问逻辑
    public abstract void Accept(IConsumer visitor);
}

public class SpecificProductA : Product 
{ 
    public int ParamA {get;set;}
    public override void Accept(IConsumer visitor)
    {
        // 调用访问者针对当前子类的处理方法
        if (visitor is ConcreteConsumerA consumerA)
        {
            consumerA.Consume(this);
        }
    }
}

public class SpecificProductB : Product 
{ 
    public int ParamB {get;set;}
    public override void Accept(IConsumer visitor)
    {
        if (visitor is ConcreteConsumerB consumerB)
        {
            consumerB.Consume(this);
        }
    }
}

然后修改Consumer接口，添加对应子类的重载方法：

public interface IConsumer 
{ 
    void Consume(Product product);
    // 针对SpecificProductA的专属处理方法
    void Consume(SpecificProductA productA);
    // 针对SpecificProductB的专属处理方法
    void Consume(SpecificProductB productB);
}

public class ConcreteConsumerA : IConsumer 
{
    public void Consume(Product product)
    {
        // 把类型判断的逻辑交给Product自己处理
        product.Accept(this);
    }

    public void Consume(SpecificProductA productA)
    {
        // 这里可以直接访问ParamA，不用再做类型转换
        Console.WriteLine($"处理SpecificProductA：{productA.ParamA}");
    }

    public void Consume(SpecificProductB productB)
    {
        // 可以根据业务需求抛出异常，或者做默认处理
        throw new NotSupportedException("ConcreteConsumerA不支持处理SpecificProductB");
    }
}

这个模式的好处是，后续新增Product子类时，只需要修改Product和对应的Consumer实现，不用改动其他代码，缺点是初期需要改造现有代码，结构稍微复杂一点。

这是最直接但最不优雅的方式，就是直接在Consume方法里做类型强转：

public class ConcreteConsumerA : IConsumer 
{
    public void Consume(Product product)
    {
        var specificA = product as SpecificProductA;
        if (specificA == null)
        {
            throw new ArgumentException("传入的产品类型无效");
        }
        // 访问专属成员
        Console.WriteLine(specificA.ParamA);
    }
}

这种方式简单粗暴，但如果后续Product子类增多，代码会充满大量的类型判断和转换，维护性很差，容易出bug，除非是临时应急，否则不推荐用。

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