C#如何在父类方法中引用子类成员？消息长度校验问题

问题根源：子类定义的messageSize是独立成员变量，和父类的同名成员互不干扰。父类的validateMessage方法访问的是父类自身的messageSize（初始值为0），因此校验逻辑始终用0判断，无法使用子类的长度值。

以下是几种可行的实现方案：

方案一：抽象父类的长度属性，子类重写实现 #

通过抽象属性强制子类提供自身的消息长度，父类校验逻辑直接使用该抽象属性，保证多态性。

abstract class MessageCreator
{
    // 抽象属性，子类必须实现自身的消息长度
    protected abstract int MessageSize { get; }

    protected void ValidateMessage(byte[] message)
    {
        if (message.Length != MessageSize)
            throw new Exception("Length not proper");
    }

    // 统一抽象Create方法，规范子类接口
    public abstract byte[] Create();
}

class XMessageCreator : MessageCreator
{
    private const int _messageSize = 10;
    protected override int MessageSize => _messageSize;

    public override byte[] Create()
    {
        byte[] message = new byte[_messageSize];
        // 此处编写X消息的具体生成逻辑
        ValidateMessage(message);
        return message;
    }
}

class YMessageCreator : MessageCreator
{
    private const int _messageSize = 20;
    protected override int MessageSize => _messageSize;

    public override byte[] Create()
    {
        byte[] message = new byte[_messageSize];
        // 此处编写Y消息的具体生成逻辑
        ValidateMessage(message);
        return message;
    }
}

方案二：使用组合+接口，解耦继承依赖 #

如果不需要继承，可以用接口定义创建器规范，再把校验逻辑封装到工具类，实现代码复用。

// 通用消息校验工具类
static class MessageValidator
{
    public static void ValidateLength(byte[] message, int expectedSize)
    {
        if (message.Length != expectedSize)
            throw new Exception("Length not proper");
    }
}

// 定义创建器接口
interface IMessageCreator
{
    byte[] Create();
}

class XMessageCreator : IMessageCreator
{
    private const int _messageSize = 10;

    public byte[] Create()
    {
        byte[] message = new byte[_messageSize];
        // 此处编写X消息的具体生成逻辑
        MessageValidator.ValidateLength(message, _messageSize);
        return message;
    }
}

class YMessageCreator : IMessageCreator
{
    private const int _messageSize = 20;

    public byte[] Create()
    {
        byte[] message = new byte[_messageSize];
        // 此处编写Y消息的具体生成逻辑
        MessageValidator.ValidateLength(message, _messageSize);
        return message;
    }
}

方案三：父类构造函数接收长度，子类传入固定值 #

父类通过构造函数接收消息长度，子类实例化时传入自身的固定长度，父类校验逻辑直接使用该值。

abstract class MessageCreator
{
    protected readonly int _messageSize;

    // 父类构造函数，接收消息长度
    protected MessageCreator(int messageSize)
    {
        _messageSize = messageSize;
    }

    protected void ValidateMessage(byte[] message)
    {
        if (message.Length != _messageSize)
            throw new Exception("Length not proper");
    }

    public abstract byte[] Create();
}

class XMessageCreator : MessageCreator
{
    // 子类构造时传入X消息的固定长度
    public XMessageCreator() : base(10) { }

    public override byte[] Create()
    {
        byte[] message = new byte[_messageSize];
        // 此处编写X消息的具体生成逻辑
        ValidateMessage(message);
        return message;
    }
}

class YMessageCreator : MessageCreator
{
    // 子类构造时传入Y消息的固定长度
    public YMessageCreator() : base(20) { }

    public override byte[] Create()
    {
        byte[] message = new byte[_messageSize];
        // 此处编写Y消息的具体生成逻辑
        ValidateMessage(message);
        return message;
    }
}

方案特点总结 #

• 方案一：利用抽象类的多态特性，逻辑集中在父类，子类只需实现长度属性，适合需要共享更多父类逻辑的场景。
• 方案二：完全解耦继承关系，代码更灵活，适合仅需复用校验逻辑的简单场景。
• 方案三：父类逻辑通用化，子类只需传入固定长度，兼顾继承的复用性和灵活性。

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