使用XMLSerialization工具解析XML时，如何跟踪表格相对段落的位置？

Great question! Let's break this down based on how XmlSerializer works and your need to track the relative positions of tables and paragraphs.

The Default XmlSerializer Limitation #

Out of the box, XmlSerializer maps XML elements directly to your class properties, but it doesn't automatically track the order or positional context of elements. If you define separate properties like List<string> Paragraphs and List<Table> Tables, you'll lose the critical information of which table comes after which paragraph—since the serializer just groups elements by their type, not their original order in the XML.

Option 1: Use [XmlAnyElement] for Manual, Order-Aware Parsing #

This is a straightforward approach to capture elements in their original sequence while still leveraging XmlSerializer for complex types like tables. Here's how to implement it:

First, define your core model classes for tables:

public class Table
{
    [XmlElement("row")]
    public List<Row> Rows { get; set; } = new List<Row>();
}

public class Row
{
    [XmlElement("entry")]
    public List<string> Entries { get; set; } = new List<string>();
}

Then create a container class that uses [XmlAnyElement] to catch all elements, then parses them into an ordered list:

[XmlRoot("document")]
public class Document
{
    // This list preserves the exact order of paragraphs and tables from the XML
    [XmlIgnore]
    public List<object> OrderedContent { get; set; } = new List<object>();

    // XmlAnyElement captures all unmapped elements for deserialization
    [XmlAnyElement]
    public XmlElement[] UnhandledElements
    {
        get => throw new InvalidOperationException("Only used for deserialization");
        set
        {
            foreach (var element in value)
            {
                switch (element.Name)
                {
                    case "paragraph":
                        // Add plain text paragraphs to the ordered list
                        OrderedContent.Add(element.InnerText);
                        break;
                    case "table":
                        // Use XmlSerializer to parse the table element into your Table class
                        var tableSerializer = new XmlSerializer(typeof(Table));
                        using var reader = new XmlNodeReader(element);
                        var table = (Table)tableSerializer.Deserialize(reader);
                        OrderedContent.Add(table);
                        break;
                    // Add cases for other element types if needed
                }
            }
        }
    }
}

With this setup, OrderedContent will hold strings (paragraphs) and Table objects in the exact order they appear in the XML—so you can easily track which table is positioned relative to which paragraphs.

Option 2: Implement IXmlSerializable for Full Control #

If you need more granular control (like handling namespaces, nested elements, or custom validation), implement the IXmlSerializable interface to manually read and write XML nodes while tracking their order.

Here's a sample implementation:

[XmlRoot("document")]
public class Document : IXmlSerializable
{
    public List<object> OrderedContent { get; set; } = new List<object>();

    public XmlSchema GetSchema() => null;

    public void ReadXml(XmlReader reader)
    {
        // Skip the root document element's start tag
        reader.ReadStartElement("document");

        while (!reader.EOF && reader.NodeType != XmlNodeType.EndElement)
        {
            switch (reader.Name)
            {
                case "paragraph":
                    // Read the paragraph text directly
                    var paragraph = reader.ReadElementContentAsString();
                    OrderedContent.Add(paragraph);
                    break;
                case "table":
                    // Deserialize the table using XmlSerializer
                    var tableSerializer = new XmlSerializer(typeof(Table));
                    var table = (Table)tableSerializer.Deserialize(reader);
                    OrderedContent.Add(table);
                    break;
                default:
                    // Skip any unknown elements to avoid breaking parsing
                    reader.Skip();
                    break;
            }
        }

        // Read the root document element's end tag
        reader.ReadEndElement();
    }

    public void WriteXml(XmlWriter writer)
    {
        // Serialize elements back to XML in the original order
        foreach (var item in OrderedContent)
        {
            if (item is string paragraph)
            {
                writer.WriteElementString("paragraph", paragraph);
            }
            else if (item is Table table)
            {
                var tableSerializer = new XmlSerializer(typeof(Table));
                tableSerializer.Serialize(writer, table);
            }
        }
    }
}

This approach gives you complete control over the parsing flow, making it easy to track positions and handle edge cases that the default serializer might miss.

Which Option to Pick? #

• Go with [XmlAnyElement] if your XML structure is simple (only paragraphs and tables) and you want a quick, low-code solution.
• Use IXmlSerializable if you need to handle complex scenarios like namespaces, mixed content within elements, or custom validation during parsing.

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