c# - 使用自定义 IXmlSerializer 反序列化注释

Question

我正在尝试序列化我的 Description Xml 注释的属性。因此，为此我实现了 IXmlSerializable以及以下 WriteXml产生非常好的 XML。

[Serializable]
public sealed class Setting<T> : SettingBase, IXmlSerializable
{
    public Setting() { }

    public Setting(T value, string description)
    {
        Value = value;
        Description = description;
    }

    public Setting(string command, T value, string description)
        : this(value, description)
    {
        Command = command;
    }

    public XmlSchema GetSchema()
    {
        return null;
    }

    public void ReadXml(XmlReader reader)
    {
    }

    public void WriteXml(XmlWriter writer)
    {
        var properties = GetType().GetProperties();
        foreach (var propertyInfo in properties)
        {
            if (propertyInfo.IsDefined(typeof(XmlCommentAttribute), false))
                writer.WriteComment(Description);
            else if (!propertyInfo.CustomAttributes.Any((attr) => attr.AttributeType.Equals(typeof(XmlIgnoreAttribute))))
                writer.WriteElementString(propertyInfo.Name, propertyInfo.GetValue(this, null)?.ToString());
        }
    }

    [XmlComment, Browsable(false)]
    public string Description { get; set; }

    [XmlElement, Browsable(false)]
    public string Command { get; set; }

    [XmlElement, Browsable(false)]
    public T Value { get; set; }

    [XmlIgnore]
    public override object ValueUntyped { get { return Value; } }
}

[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
public class XmlCommentAttribute : Attribute {}

但是，我曾多次尝试实现 ReadXml但我似乎无法反序列化 Description评论。

我该如何实现 ReadXml使我的类(class)脱轨？

Answer 1

实现时IXmlSerializable您需要遵守 this answer 中规定的规则至 Proper way to implement IXmlSerializable?来自 Marc Gravell以及文档:

对于 IXmlSerializable.WriteXml(XmlWriter) :

The WriteXml implementation you provide should write out the XML representation of the object. The framework writes a wrapper element and positions the XML writer after its start. Your implementation may write its contents, including child elements. The framework then closes the wrapper element.

对于 IXmlSerializable.ReadXml(XmlReader) :

The ReadXml method must reconstitute your object using the information that was written by the WriteXml method.

When this method is called, the reader is positioned on the start tag that wraps the information for your type. That is, directly on the start tag that indicates the beginning of a serialized object. When this method returns, it must have read the entire element from beginning to end, including all of its contents. Unlike the WriteXml method, the framework does not handle the wrapper element automatically. Your implementation must do so. Failing to observe these positioning rules may cause code to generate unexpected runtime exceptions or corrupt data.

事实证明，写一个 ReadXml() 非常棘手。正确处理边缘情况，例如乱序或意外元素、缺失或多余空格、空元素等。因此，采用某种解析框架来正确遍历 XML 树是有意义的，例如 this one来自 Why does XmlSerializer throws an Exception and raise a ValidationEvent when a schema validation error occurs inside IXmlSerializable.ReadXml() ，并将其扩展为处理评论节点:

public static class XmlSerializationExtensions
{
    // Adapted from this answer https://stackoverflow.com/a/60498500/3744182
    // To https://stackoverflow.com/questions/60449088/why-does-xmlserializer-throws-an-exception-and-raise-a-validationevent-when-a-sc
    // by handling comments.
    public static void ReadIXmlSerializable(XmlReader reader, Func<XmlReader, bool> handleXmlAttribute, Func<XmlReader, bool> handleXmlElement, Func<XmlReader, bool> handleXmlText, Func<XmlReader, bool> handleXmlComment)
    {
        //https://docs.microsoft.com/en-us/dotnet/api/system.xml.serialization.ixmlserializable.readxml?view=netframework-4.8#remarks
        //When this method is called, the reader is positioned on the start tag that wraps the information for your type. 
        //That is, directly on the start tag that indicates the beginning of a serialized object. 
        //When this method returns, it must have read the entire element from beginning to end, including all of its contents. 
        //Unlike the WriteXml method, the framework does not handle the wrapper element automatically. Your implementation must do so. 
        //Failing to observe these positioning rules may cause code to generate unexpected runtime exceptions or corrupt data.
        reader.MoveToContent();
        if (reader.NodeType != XmlNodeType.Element)
            throw new XmlException(string.Format("Invalid NodeType {0}", reader.NodeType));
        if (reader.HasAttributes)
        {
            for (int i = 0; i < reader.AttributeCount; i++)
            {
                reader.MoveToAttribute(i);
                handleXmlAttribute(reader);
            }
            reader.MoveToElement(); // Moves the reader back to the element node.
        }
        if (reader.IsEmptyElement)
        {
            reader.Read();
            return;
        }
        reader.ReadStartElement(); // Advance to the first sub element of the wrapper element.
        while (reader.NodeType != XmlNodeType.EndElement)
        {
            if (reader.NodeType == XmlNodeType.Element)
            {
                using (var subReader = reader.ReadSubtree())
                {
                    subReader.MoveToContent();
                    handleXmlElement(subReader);
                }
                // ReadSubtree() leaves the reader positioned ON the end of the element, so read that also.
                reader.Read();
            }
            else if (reader.NodeType == XmlNodeType.Text || reader.NodeType == XmlNodeType.CDATA)
            {
                var type = reader.NodeType;
                handleXmlText(reader);
                // Ensure that the reader was not advanced.
                if (reader.NodeType != type)
                    throw new XmlException(string.Format("handleXmlText incorrectly advanced the reader to a new node {0}", reader.NodeType));
                reader.Read();
            }
            else if (reader.NodeType == XmlNodeType.Comment)
            {
                var type = reader.NodeType;
                handleXmlComment(reader);
                // Ensure that the reader was not advanced.
                if (reader.NodeType != type)
                    throw new XmlException(string.Format("handleXmlComment incorrectly advanced the reader to a new node {0}", reader.NodeType));
                reader.Read();
            }
            else // Whitespace, etc.
            {
                // Skip() leaves the reader positioned AFTER the end of the node.
                reader.Skip();
            }
        }
        // Move past the end of the wrapper element
        reader.ReadEndElement();
    }

    public static void ReadIXmlSerializable(XmlReader reader, Func<XmlReader, bool> handleXmlAttribute, Func<XmlReader, bool> handleXmlElement, Func<XmlReader, bool> handleXmlText)
    {
        ReadIXmlSerializable(reader, handleXmlAttribute, handleXmlElement, handleXmlText, r => true);
    }

    public static void WriteIXmlSerializable(XmlWriter writer, Action<XmlWriter> writeAttributes, Action<XmlWriter> writeNodes)
    {
        //https://docs.microsoft.com/en-us/dotnet/api/system.xml.serialization.ixmlserializable.writexml?view=netframework-4.8#remarks
        //The WriteXml implementation you provide should write out the XML representation of the object. 
        //The framework writes a wrapper element and positions the XML writer after its start. Your implementation may write its contents, including child elements. 
        //The framework then closes the wrapper element.
        writeAttributes(writer);
        writeNodes(writer);
    }
}

public static class XmlSerializerFactory
{
    // To avoid a memory leak the serializer must be cached.
    // https://stackoverflow.com/questions/23897145/memory-leak-using-streamreader-and-xmlserializer
    // This factory taken from 
    // https://stackoverflow.com/questions/34128757/wrap-properties-with-cdata-section-xml-serialization-c-sharp/34138648#34138648

    readonly static Dictionary<Tuple<Type, string, string>, XmlSerializer> cache;
    readonly static object padlock;

    static XmlSerializerFactory()
    {
        padlock = new object();
        cache = new Dictionary<Tuple<Type, string, string>, XmlSerializer>();
    }

    public static XmlSerializer Create(Type serializedType, string rootName, string rootNamespace)
    {
        if (serializedType == null)
            throw new ArgumentNullException();
        if (rootName == null && rootNamespace == null)
            return new XmlSerializer(serializedType);
        lock (padlock)
        {
            XmlSerializer serializer;
            var key = Tuple.Create(serializedType, rootName, rootNamespace);
            if (!cache.TryGetValue(key, out serializer))
                cache[key] = serializer = new XmlSerializer(serializedType, new XmlRootAttribute { ElementName = rootName, Namespace = rootNamespace });
            return serializer;
        }
    }
}

然后修改您的类以使用它，如下所示:

[Serializable]
public sealed class Setting<T> : SettingBase, IXmlSerializable
{
    public Setting() { }

    public Setting(T value, string description)
    {
        Value = value;
        Description = description;
    }

    public Setting(string command, T value, string description)
        : this(value, description)
    {
        Command = command;
    }

    public XmlSchema GetSchema() { return null;}

    public void ReadXml(XmlReader reader)
    {
        XmlSerializationExtensions.ReadIXmlSerializable(reader, r => true,
            r =>
            {
                switch (r.LocalName)
                {
                    case "Command":
                        Command = r.ReadElementContentAsString();
                        break;
                    case "Value":
                        var serializer = XmlSerializerFactory.Create(typeof(T), "Value", reader.NamespaceURI);
                        Value = (T)serializer.Deserialize(r);
                        break;
                }
                return true;
            },
            r => true, r => { Description += r.Value; return true; });
    }

    public void WriteXml(XmlWriter writer)
    {
        XmlSerializationExtensions.WriteIXmlSerializable(writer, w => { },
            w =>
            {
                if (Description != null)
                    w.WriteComment(Description);
                if (Command != null)
                    w.WriteElementString("Command", Command);
                if (Value != null)
                {
                    var serializer = XmlSerializerFactory.Create(typeof(T), "Value", null);
                    serializer.Serialize(w, Value);
                }
            });
    }

    public string Description { get; set; }

    public string Command { get; set; }

    public T Value { get; set; }

    public override object ValueUntyped { get { return Value; } }
}

// ABSTRACT BASE CLASS NOT INCLUDED IN QUESTION, THIS IS JUST A GUESS
[Serializable]
public abstract class SettingBase
{
    public abstract object ValueUntyped { get; }
}

并且您将能够将其往返传输到 XML。

笔记:

由于您的类是密封的，因此我将反射的使用替换为直接访问要序列化的属性。

在您的版本中，您序列化了 T Value通过编写其 ToString() 到 XML值(value):

writer.WriteElementString(propertyInfo.Name, propertyInfo.GetValue(this, null)?.ToString());

除非值本身是一个字符串，否则这很可能会产生错误的结果:

数字，DateTime , TimeSpan和类似的原语将是 本地化 . XML 原语应始终以文化上不变的方式进行格式化。

复杂对象，如 string []不覆盖 ToString()将以完全不正确的方式格式化。

为了避免这些问题，我的版本通过构造一个合适的 XmlSerializer 将值序列化为 XML。 .这保证了正确性，但可能比您的版本慢。如果性能在这里很重要，您可以检查已知类型(例如 string )并手动将它们格式化为 XML，例如使用实用程序类 XmlConvert .

XmlReader.ReadSubtree() 用于确保XmlReader没有被 HandleXmlElement(XmlReader reader) 错位.

演示 fiddle here .