3

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

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

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

这可以持续 X 代，但我想强制每个类都必须实现SerializeProperties，我想在不使用反射的情况下完成所有这些。

此外，如果我有如下声明：

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

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

即分别调用类的SerializeProperties方法，BaseMessage类的SerializeProperties方法，BaseCommandMessage最后调用类SerializeProperties的方法CommandMessage。

我希望这是有道理的！

谢谢

ps

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

4

2 回答 2

4

确保为SerializePropertiesfirst 提供重载的每个类都调用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();
    }
}
于 2013-05-30T22:30:18.653 回答
0

我可以用一代来做到这一点，即在我的基类中，我有一个名为 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);
    }
}
于 2013-05-30T22:55:46.827 回答