Question

我遇到了.Net XmlSerializer的问题，基本上我需要一个或多个具有相同名称的元素在固定模式的其他元素之间动态地序列化（和反序列化）。

示例：

<?xml version="1.0" encoding="utf-8"?>
<A xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <asd>asd</asd>
  <nnn>q</nnn>
  <nnn>w</nnn>
  <nnn>e</nnn>
  <aaa>aaa</aaa>
</A>

我的真实<nnn>标签有点复杂，里面有动态标签（不仅仅是条件），但我目前正在威胁这一点。我真的需要使用XmlElement的“Order”参数来控制一些规则。

我无法更改XML布局。

示例可序列化类：

[XmlRoot]
[Serializable]
public class A
{
    [XmlElement("asd", Order=1)]
    public string asd { get; set; }

    [XmlIgnore]
    public string[] qwe { get; set; }

    [XmlAnyElement("nnn", Order=2)]
    public XmlNode[] nnn
    {
        get
        {
            if (qwe == null) return null;

            var xml = new XmlDocument();
            var nodes = new List<XmlNode>(qwe.Length);

            foreach (var q in qwe)
            {
                var nnnTag = xml.CreateNode(XmlNodeType.Element, "nnn", null);
                nnnTag.InnerText = q;
                nodes.Add(nnnTag);
            }

            return nodes.ToArray();
        }
        set
        {
            if (value == null) return;
            qwe = value.Select(tag => tag.InnerText).ToArray();
        }
    }

    [XmlElement("aaa", Order=3)]
    public string aaa { get; set; }

问题是，当不使用“Order”参数时，序列化很顺利，但是使用参数，XmlAnyElement之后的元素被理解为节点数组的一部分，因此不会反序列化。 / p>

我的示例主程序是一个控制台应用程序，主要包含以下内容：

static void Main(string[] args)
{
    var a = new A
    {
        aaa = "aaa",
        asd = "asd",
        qwe = new[] {"q", "w", "e"}
    };
    var s = Serialize(a);
    var ss = Deserialize<A>(s);
    var s2 = Serialize(ss);

    Console.WriteLine(s);
    Console.WriteLine(s2);

    Console.WriteLine("Equals: {0};", s == s2);

    Console.ReadKey();
}

错误的输出是：

<?xml version="1.0" encoding="utf-8"?>
<A xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <asd>asd</asd>
  <nnn>q</nnn>
  <nnn>w</nnn>
  <nnn>e</nnn>
  <aaa>aaa</aaa>
</A>
<?xml version="1.0" encoding="utf-8"?>
<A xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <asd>asd</asd>
  <nnn>q</nnn>
  <nnn>w</nnn>
  <nnn>e</nnn>
  <nnn>aaa</nnn>
</A>
Equals: False;

对于测试，这是我正在使用的序列化/反序列化片段：

public static string Serialize<T>(T a)
{
    var s = new XmlSerializer(typeof(T));
    using (var ms = new MemoryStream())
    {
        using (TextWriter sw = new StreamWriter(ms))
        {
            s.Serialize(sw, a);
            ms.Seek(0, 0);
            using (var sr = new StreamReader(ms))
            {
                return sr.ReadToEnd();
            }
        }
    }
}

public static T Deserialize<T>(string a)
{
    var s = new XmlSerializer(typeof(T));
    var bytes = Encoding.ASCII.GetBytes(a);
    using (var ms = new MemoryStream(bytes))
    {
        return (T) s.Deserialize(ms);
    }
}

完整的源代码： https://gist.github.com/inventti-gabriel/81054269f2e0a32d7e8d1dd44f30a97f

提前致谢。

Answer 1

我同意@CharlesMager，这似乎是XmlSerializer中的错误。

话虽这么说，你可以通过引入一个中间包装类或结构来包含任意节点来解决这个问题，然后修改你的代理nnn属性，在用{标记属性后返回这些结构的数组{1}}：

[XmlElement("nnn", Order = 2)]

请注意，[XmlRoot] [Serializable] public class A { [XmlElement("asd", Order = 1)] public string asd { get; set; } [XmlIgnore] public string[] qwe { get; set; } [XmlElement("nnn", Order = 2)] public XmlNodeWrapper [] nnn { get { if (qwe == null) return null; var xml = new XmlDocument(); var nodes = new List<XmlNode>(qwe.Length); foreach (var q in qwe) { var nnnTag = xml.CreateNode(XmlNodeType.Element, "nnn", null); nnnTag.InnerText = q; nodes.Add(nnnTag); } return nodes.Select(n => (XmlNodeWrapper)n.ChildNodes).ToArray(); } set { if (value == null) return; qwe = value.Select(tag => tag.InnerText()).ToArray(); } } [XmlElement("aaa", Order = 3)] public string aaa { get; set; } } [XmlType(AnonymousType = true)] public struct XmlNodeWrapper { public static implicit operator XmlNodeWrapper(XmlNodeList nodes) { return new XmlNodeWrapper { Nodes = nodes == null ? null : nodes.Cast<XmlNode>().ToArray() }; } public static implicit operator XmlNode[](XmlNodeWrapper wrapper) { return wrapper.Nodes; } // Marking the Nodes property with both [XmlAnyElement] and [XmlText] indicates that the node array // may contain mixed content (I.e. both XmlElement and XmlText objects). // Hat tip: https://stackoverflow.com/questions/25995609/xmlserializer-node-containing-text-xml-text [XmlAnyElement] [XmlText] public XmlNode[] Nodes { get; set; } public string InnerText() { if (Nodes == null) return null; return String.Concat(Nodes.Select(n => n.InnerText)); } }中的Nodes媒体资源标有XmlNodeWrapper和[XmlAnyElement]。 here解释了执行此操作的要求。

示例fiddle。

Answer 2

尝试使用XmlArrayAttribute代替XmlAnyElement，因为节点是数组

XmlSerialization，XmlAnyElement到XmlNode和Order属性

2 个答案: