如何在父类上调用方法，并在c#中将该方法调用链接到它的继承层次结构

本文关键字：调用 方法 链接 层次结构 继承 父类 并在 | 更新日期: 2023-09-27 18:16:04

我有一个抽象基类(BaseMessage)，其方法SerializeProperties将其所有属性序列化为字节数组，并将其保存在类型为byte[]的受保护变量中。

有一个继承自这个抽象基类(BaseCommandMessage)的类，它也是抽象的，并引入了一些更多的属性。我希望这个类实现SerializeProperties强制它序列化所有的本地属性，并将其添加到字节数组。

之后，我有一个具体的类，继承自抽象类(CommandMessage)，需要实现SerializeProperties和序列化它的属性到字节数组。

这可以持续X代，但我想强制每个类必须实现SerializeProperties和我想做所有这些不使用反射。

此外，如果我有这样的语句:

BaseMessage message = new CommandMessage();
message.SerializeProperties();

它应该序列化BaseMessage属性，BaseCommandMessage属性，最后是CommandMessage属性。

。分别调用BaseMessage类的SerializeProperties方法、BaseCommandMessage类的SerializeProperties方法和CommandMessage类的SerializeProperties方法。

我希望这是有意义的!

感谢

注。

我可以这样做与一代，即在我的基类我有一个实现的方法称为SerializeMyProperties序列化它的所有属性，然后调用抽象或虚拟方法SerializeProperties继承类可以实现。这样它就序列化了它自己的属性然后序列化了继承的类但是我不能超过2代

如何在父类上调用方法，并在c#中将该方法调用链接到它的继承层次结构

确保每个为SerializeProperties提供重载的类首先调用base.SerializeProperties。最好将方法更改为返回字节，然后每生成一代增加数组。这应该允许每一代人做他们需要做的事，并使后代能够做他们需要做的事。

class BaseMessage
{
    protected virtual byte[] SerializeProperties()
    {
        var bytes = new List<byte>();
        bytes.AddRange(...); // serialize BaseMessage properties
        return bytes.ToArray();
    }
}
class BaseCommandMessage
{
    protected override byte[] SerializeProperties()
    {
        var bytes = new List<byte>(base.SerializeProperties());
        bytes.AddRange(...); // serialize BaseCommandMessage properties
        return bytes.ToArray();
    }
}
class CommandMessage
{
    protected override byte[] SerializeProperties()
    {
        // A call to this method will call BaseCommandMessage.SerializeProperties,
        //   and indirectly call BaseMessage.SerializeProperties
        var bytes = new List<byte>(base.SerializeProperties());
        bytes.AddRange(...); // serialize CommandMessage properties
        return bytes.ToArray();
    }
}

我可以这样做与一代，即在我的基类我有一个实现的方法称为SerializeMyProperties序列化它的所有属性，然后调用抽象或虚拟方法SerializeProperties继承类可以实现。这样，它序列化它自己的属性，然后序列化继承的类，但我不能超过+2代。

你可能有它，你可能只是在如何处理SerializeMyProperties上犯了一个错误。这是我使用的模式。暴露给用户的公共类是非虚拟的(这一步不是必要的，但是如果基类需要在聚合工作上执行一些额外的步骤，就像我对ToArray()的调用一样，它会很方便)，它调用一个私有的虚拟函数，其中每个子函数在开始做它的工作之前调用它的父函数的版本。

abstract class Foo
{
    public byte[] SerializeProperties()
    {
         var props = new List<byte>();
         SerializeMyProperties(props);
         return props.ToArray();
    }
    private virtual void SerializeMyProperties(List<byte> props)
    {
        byte[] serializedByteArrayForThisInstance;
        //Magic!
         props.AddRange(serializedByteArrayForThisInstance);
    }
}
class Bar : Foo
{
    private virtual void SerializeMyProperties(List<byte> props)
    {
        //Call the Foo's SerializeMyProperties first so it fills the first part of the list
        base.SerializeMyProperties(props);
        byte[] serializedByteArrayForThisInstanceToo;
        //Even More Magic!
         props.AddRange(serializedByteArrayForThisInstanceToo);
    }
}
class Baz : Bar
{
    private virtual void SerializeMyProperties(List<byte> props)
    {
        //Call the Bar's SerializeMyProperties first so it fills the first two parts of the list
        base.SerializeMyProperties(props);
        byte[] iAmRunningOutOfVariableNames;
        //Here Be Dragons!
         props.AddRange(iAmRunningOutOfVariableNames);
    }
}
相关文章：