实现 IXmlSerializable 的正确方法？答案

【问题标题】：Proper way to implement IXmlSerializable?实现 IXmlSerializable 的正确方法？
【发布时间】：2010-09-21 17:27:11
【问题描述】：

一旦程序员决定实现IXmlSerializable，实现它的规则和最佳实践是什么？我听说GetSchema() 应该返回null 和ReadXml 应该在返回之前移动到下一个元素。这是真的？那么WriteXml 呢？它应该为对象写一个根元素还是假设根已经写了？子对象应该如何处理和写入？

这是我现在拥有的样本。我会在收到好的回复后更新它。

public class MyCalendar : IXmlSerializable
{
    private string _name;
    private bool _enabled;
    private Color _color;
    private List<MyEvent> _events = new List<MyEvent>();


    public XmlSchema GetSchema() { return null; }

    public void ReadXml(XmlReader reader)
    {
        if (reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == "MyCalendar")
        {
            _name    = reader["Name"];
            _enabled = Boolean.Parse(reader["Enabled"]);
            _color   = Color.FromArgb(Int32.Parse(reader["Color"]));

            if (reader.ReadToDescendant("MyEvent"))
            {
                while (reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == "MyEvent")
                {
                    MyEvent evt = new MyEvent();
                    evt.ReadXml(reader);
                    _events.Add(evt);
                }
            }
            reader.Read();
        }
    }

    public void WriteXml(XmlWriter writer)
    {
        writer.WriteAttributeString("Name",    _name);
        writer.WriteAttributeString("Enabled", _enabled.ToString());
        writer.WriteAttributeString("Color",   _color.ToArgb().ToString());

        foreach (MyEvent evt in _events)
        {
            writer.WriteStartElement("MyEvent");
            evt.WriteXml(writer);
            writer.WriteEndElement();
        }
    }
}

public class MyEvent : IXmlSerializable
{
    private string _title;
    private DateTime _start;
    private DateTime _stop;


    public XmlSchema GetSchema() { return null; }

    public void ReadXml(XmlReader reader)
    {
        if (reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == "MyEvent")
        {
            _title = reader["Title"];
            _start = DateTime.FromBinary(Int64.Parse(reader["Start"]));
            _stop  = DateTime.FromBinary(Int64.Parse(reader["Stop"]));
            reader.Read();
        }
    }

    public void WriteXml(XmlWriter writer)
    {
        writer.WriteAttributeString("Title", _title);
        writer.WriteAttributeString("Start", _start.ToBinary().ToString());
        writer.WriteAttributeString("Stop",  _stop.ToBinary().ToString());
    }
}

对应的示例 XML

<MyCalendar Name="Master Plan" Enabled="True" Color="-14069085">
    <MyEvent Title="Write Code" Start="-8589241828854775808" Stop="-8589241756854775808" />
    <MyEvent Title="???" Start="-8589241828854775808" Stop="-8589241756854775808" />
    <MyEvent Title="Profit!" Start="-8589247048854775808" Stop="-8589246976854775808" />
</MyCalendar>

【问题讨论】：

您能在这个问题中添加一个 xml 示例吗？这将使与代码一起阅读变得更简单。谢谢！
如何处理在您的 xml 中的最后一个事件之后有 XML 注释等的情况。即，您是否应该使用检查您是否通读到结束元素的内容来完成 ReadXml() 方法？目前这假设最后一个 Read() 会这样做，但可能并不总是这样。
@Rory - 添加了示例。迟到总比没有好？
@Greg 好信息。难道您不想让 ReadXml 和 WriteXml 使用不变文化吗？我认为如果用户搬到另一个国家并更改了他们的区域和语言设置，您可能会遇到问题。在这种情况下，代码可能无法正确反序列化。我读过，在进行序列化时始终使用不变文化是最佳实践

标签： c# xml xml-serialization

【解决方案1】：

是的，GetSchema() should return null。

IXmlSerializable.GetSchema 方法 This 方法是保留的，不应该是用过的。实施时 IXmlSerializable 接口，你应该返回一个空引用（没有 Visual Basic) 从这个方法，而是，如果指定自定义架构是需要，应用 XmlSchemaProviderAttribute 到类。

对于read和write来说，object元素已经被写入了，所以你不需要在write中添加外部元素。例如，您可以在两者中开始读取/写入属性。

对于write：

你的 WriteXml 实现提供应该写出 XML 对象的表示。这框架编写一个包装元素和将 XML 编写器定位在其之后开始。您的实现可能会写它的内容，包括孩子元素。然后框架关闭包装元素。

对于read：

ReadXml 方法必须重构您的对象使用的信息是用 WriteXml 方法写的。

调用此方法时，阅读器位于开头包装信息的元素你的类型。也就是说，就在表示开始的开始标签一个序列化的对象。当这方法返回，它必须已读取从头到尾的整个元素，包括其所有内容。不像 WriteXml 方法，框架不处理包装元素自动地。您的实施必须这样做。不遵守这些定位规则可能会导致代码生成意外的运行时异常或损坏的数据。

我同意这有点不清楚，但归结为“Read() 包装器的结束元素标记是你的工作”。

【讨论】：

写出和读取事件元素怎么样？手动编写起始元素感觉很骇人听闻。我想我见过有人在 write 方法中使用 XmlSerializer 来编写每个子元素。
@Greg;两种用法都可以……是的，如果需要，您可以使用嵌套的 XmlSerializer，但这不是唯一的选择。
感谢这些精确度，MSDN 中的示例代码对此非常无用且不清楚。我被卡住了很多次，想知道 Read/WriteXml 的不对称行为。
@MarcGravell 我知道这是一个旧线程。 “框架编写一个包装器元素并在 XML 编写器启动后定位它。”这就是我挣扎的地方。有没有办法强制框架跳过自动处理包装器的这一步？我有一种情况需要跳过这一步：stackoverflow.com/questions/20885455/…
@James 据我所知不是

【解决方案2】：

我写了一篇关于这个主题的文章，其中包含示例，因为 MSDN 文档现在还很不清楚，而且您可以在网络上找到的示例大部分时间都没有正确实现。

除了 Marc Gravell 已经提到的内容之外，还有处理语言环境和空元素的陷阱。

http://www.codeproject.com/KB/XML/ImplementIXmlSerializable.aspx

【讨论】：

优秀的文章！下次我要序列化一些数据时一定会参考它。
谢谢！积极反馈的数量奖励了投入编写它的时间。我非常感谢你喜欢它！不要犹豫，要求批评一些观点。
示例比引用 MSDN 有用得多。
感谢代码项目，如果可以的话，我也会投赞成票。与 MSDN 相比，属性方面的内容非常全面。例如，我的 : IXMLSerializable 类在以 xsd.exe 生成 [Serializable(), XmlType(Namespace = "MonitorService")] 为前缀时中断。

【解决方案3】：

是的，整个事情有点像雷区，不是吗？ Marc Gravell 的回答几乎涵盖了它，但我想补充一点，在我从事的一个项目中，我们发现必须手动编写外部 XML 元素非常尴尬。它还导致相同类型的对象的 XML 元素名称不一致。

我们的解决方案是定义我们自己的IXmlSerializable 接口，该接口源自系统接口，它添加了一个名为WriteOuterXml() 的方法。正如你所猜想的那样，这个方法会简单地写入外部元素，然后调用WriteXml()，然后写入元素的结尾。当然，系统 XML 序列化程序不会调用此方法，因此它仅在我们自己进行序列化时才有用，因此这可能对您的情况有帮助，也可能没有帮助。同样，我们添加了一个ReadContentXml() 方法，它不读取外部元素，只读取其内容。

【讨论】：

使用 C# 3.0，您可能可以通过编写扩展方法来做到这一点，但这是一个有趣的想法。

【解决方案4】：

如果您已经拥有类的 XmlDocument 表示或更喜欢 XmlDocument 方式来处理 XML 结构，那么实现 IXmlSerializable 的一种快速而肮脏的方式就是将此 xmldoc 传递给各种函数。

警告：XmlDocument（和/或 XDocument）比 xmlreader/writer 慢一个数量级，因此如果性能是绝对要求，那么此解决方案不适合您！

class ExampleBaseClass : IXmlSerializable { 
    public XmlDocument xmlDocument { get; set; }
    public XmlSchema GetSchema()
    {
        return null;
    }
    public void ReadXml(XmlReader reader)
    {
        xmlDocument.Load(reader);
    }

    public void WriteXml(XmlWriter writer)
    {
        xmlDocument.WriteTo(writer);
    }
}

【讨论】：

【解决方案5】：

其他答案涵盖了接口实现，但我想为根元素投入 2 美分。

我过去学会了更喜欢将根元素作为元数据。这有几个好处：

如果有空对象，仍然可以序列化
从代码可读性的角度来看，这是有道理的

以下是可序列化字典的示例，其中字典根元素以这种方式定义：

using System.Collections.Generic;

[System.Xml.Serialization.XmlRoot("dictionary")]
public partial class SerializableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, System.Xml.Serialization.IXmlSerializable
{
            public virtual System.Xml.Schema.XmlSchema GetSchema()
    {
        return null;
    }

    public virtual void ReadXml(System.Xml.XmlReader reader)
    {
        var keySerializer = new System.Xml.Serialization.XmlSerializer(typeof(TKey));
        var valueSerializer = new System.Xml.Serialization.XmlSerializer(typeof(TValue));
        bool wasEmpty = reader.IsEmptyElement;
        reader.Read();
        if (wasEmpty)
            return;
        while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
        {
            reader.ReadStartElement("item");
            reader.ReadStartElement("key");
            TKey key = (TKey)keySerializer.Deserialize(reader);
            reader.ReadEndElement();
            reader.ReadStartElement("value");
            TValue value = (TValue)valueSerializer.Deserialize(reader);
            reader.ReadEndElement();
            Add(key, value);
            reader.ReadEndElement();
            reader.MoveToContent();
        }

        reader.ReadEndElement();
    }

    public virtual void WriteXml(System.Xml.XmlWriter writer)
    {
        var keySerializer = new System.Xml.Serialization.XmlSerializer(typeof(TKey));
        var valueSerializer = new System.Xml.Serialization.XmlSerializer(typeof(TValue));
        foreach (TKey key in Keys)
        {
            writer.WriteStartElement("item");
            writer.WriteStartElement("key");
            keySerializer.Serialize(writer, key);
            writer.WriteEndElement();
            writer.WriteStartElement("value");
            var value = this[key];
            valueSerializer.Serialize(writer, value);
            writer.WriteEndElement();
            writer.WriteEndElement();
        }
    }

    public SerializableDictionary() : base()
    {
    }

    public SerializableDictionary(IDictionary<TKey, TValue> dictionary) : base(dictionary)
    {
    }

    public SerializableDictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer) : base(dictionary, comparer)
    {
    }

    public SerializableDictionary(IEqualityComparer<TKey> comparer) : base(comparer)
    {
    }

    public SerializableDictionary(int capacity) : base(capacity)
    {
    }

    public SerializableDictionary(int capacity, IEqualityComparer<TKey> comparer) : base(capacity, comparer)
    {
    }

}

【讨论】：