序列化派生类型的派生类型属性数组

Question

我有一个简单的 .Net 框架 C# 控制台应用程序，它序列化一个属于派生类型的类，其中一个属性也是派生类型。

派生类的名称与基类相同，但位于不同的命名空间中以防止它们发生冲突。 XmlSerializer 使用的反射似乎不适用于此。也许有一些方法可以解决我仍然可以使用漂亮名称（因为使用时它将是一个 DLL 接口）和 XML 也使用漂亮名称（因为它将是人类可编辑的）的属性。 . 派生类的漂亮名称不是必需的（尽管会是一个奖励）。

希望 XML 看起来像：

<?xml version="1.0" encoding="utf-8"?>
<Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Details>
    <Detail>
      <Description>bald</Description>
    </Detail>
    <Detail>
      <Description>red tie</Description>
    </Detail>
  </Details>
</Person>

但毫无例外我能得到的最接近的是<Detail> 元素的位置

    <Detail xsi:type="DerivedDetail"> ... </Detail>

必须添加这个xs:type 属性对于人工可编辑的 XML 来说并不是最好的。

这是通过以下 C# 代码实现的。如果我删除了标记的 XmlType 属性，那么元素 应该 在没有 xsi:type 属性的情况下进行序列化，但是我得到了一个异常：

InvalidOperationException：类型“Test.Detail”和“Test.Xml.Detail”都使用命名空间“”中的 XML 类型名称“Detail”。使用 XML 属性为类型指定唯一的 XML 名称和/或命名空间。

我尝试将派生的 Xml.Detail 类标记为匿名 XML 类型，但异常显示为：

InvalidOperationException：不能包含匿名类型“Test.Xml.Detail”。

我已经阅读了许多类似的问题，但还没有遇到任何解决此问题的方法。

在下面的这段代码中，Person 是一个抽象类，它的属性是一个抽象类型为Detail 的数组。这些类型分别由Xml.Person 和Xml.Detail 派生。该程序创建一个测试Xml.Person 对象并尝试对其进行序列化：

using System;
using System.Text;
using System.IO;
using System.Xml;
using System.Xml.Serialization;

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create test details array
            var TestDetails = new Xml.Detail[] 
            {
                new Xml.Detail
                {
                    Description = "bald"
                },
                new Xml.Detail
                {
                    Description = "red tie"
                }
            };

            // create test person object that holds details array
            var TestBar = new Xml.Person()
            {
                Details = TestDetails
            };

            // serialize the person object
            var s = new Xml.Serializer();
            var TestOutput = s.Serialize(TestBar);

            Console.WriteLine(TestOutput);
        }
    }

    // base classes
    public abstract class Person
    {
        public abstract Detail[] Details { get; set; }
    }

    public abstract class Detail
    {
        public abstract string Description { get; set; }
    }

    namespace Xml
    {
        // derived classes
        [Serializable]
        [XmlType(AnonymousType = true)]
        [XmlRoot(IsNullable = false)]
        public class Person : Test.Person
        {
            [XmlArrayItem("Detail", typeof(Detail))]
            [XmlArray(IsNullable = false)]
            public override Test.Detail[] Details { get; set; }
        }

        // This attribute makes serialization work but also adds the xsi:type attribute
        [XmlType("DerivedDetail")]
        [Serializable]
        public class Detail : Test.Detail
        {
            public override string Description { get; set; }
        }

        // class that does serializing work
        public class Serializer
        {
            private static XmlSerializer PersonSerializer = 
                new XmlSerializer(typeof(Person), new Type[] { typeof(Detail) });

            public string Serialize(Test.Person person)
            {
                string Output = null;
                var Stream = new MemoryStream();
                var Encoding = new UTF8Encoding(false, true);

                using (var Writer = new XmlTextWriter(Stream, Encoding))
                {
                    Writer.Formatting = Formatting.Indented;
                    PersonSerializer.Serialize(Writer, person);
                    Output = Encoding.GetString(Stream.ToArray());
                }
                Stream.Dispose();
                return Output;
            }
        }
    }
}

Answer 1

当您没有任何成员字段时，不确定为什么要使用基类而不是接口。无论如何，我假设您希望 Xml.Person 成为抽象 Person 或从抽象 Person 派生的任何类的具体实例，而不用 XML 属性装饰抽象 Person。我通过在序列化之前强制抽象Person 成为Xml.Person 的具体实例来实现这一点。请将XmlSerializationProject 替换为Test。

using System;
using System.IO;
using System.Text;
using System.Xml;
using System.Xml.Serialization;

namespace XmlSerializationProject
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create test details array
            var TestDetails = new Xml.Detail[]
            {
                new Xml.Detail
                {
                    Description = "bald"
                },
                new Xml.Detail
                {
                    Description = "red tie"
                }
            };

            // create test person object that holds details array
            var TestBar = new Xml.Person()
            {
                Details = TestDetails
            };

            // serialize the person object
            var s = new Xml.Serializer();
            var TestOutput = s.Serialize(TestBar);

            Console.WriteLine(TestOutput);
            Console.ReadKey();
        }
    }

    // base classes
    public abstract class Person
    {
        public abstract Detail[] Details { get; set; }
    }

    public abstract class Detail
    {
        public abstract string Description { get; set; }
    }

    namespace Xml
    {
        [Serializable]
        [XmlType(AnonymousType = true)]
        [XmlRoot(IsNullable = false)]
        public class Person : XmlSerializationProject.Person
        {
            public Person()
            { }

            public Person(XmlSerializationProject.Person person)
            {
                // Deep copy
                if (person.Details == null) return;
                this.Details = new Detail[person.Details.Length];
                for (int i = 0; i < person.Details.Length; i++)
                {
                    this.Details[i] = new Detail { Description = person.Details[i].Description };
                }
            }

            [XmlArray(ElementName = "Details")]
            [XmlArrayItem("Detail", typeof(Detail))]
            [XmlArrayItem("ODetail", typeof(XmlSerializationProject.Detail))]
            public override XmlSerializationProject.Detail[] Details
            {
                get;
                set;
            }
        }

        [Serializable]
        public class Detail : XmlSerializationProject.Detail
        {
            public override string Description { get; set; }
        }

        // class that does serializing work
        public class Serializer
        {
            private static readonly XmlSerializer PersonSerializer;

            private static Serializer()
            {
                var xmlAttributeOverrides = new XmlAttributeOverrides();
                // Change original "Detail" class's element name to "AbstractDetail"
                var xmlAttributesOriginalDetail = new XmlAttributes();
                xmlAttributesOriginalDetail.XmlType = new XmlTypeAttribute() { TypeName = "AbstractDetail" };
                xmlAttributeOverrides.Add(typeof(XmlSerializationProject.Detail), xmlAttributesOriginalDetail);

                // Ignore Person.Details array
                var xmlAttributesOriginalDetailsArray = new XmlAttributes();
                xmlAttributesOriginalDetailsArray.XmlIgnore = true;
                xmlAttributeOverrides.Add(typeof(XmlSerializationProject.Person), "Details", xmlAttributesOriginalDetailsArray);

                PersonSerializer = new XmlSerializer(
                    typeof(Person), xmlAttributeOverrides, new Type[] { typeof(Detail) }, new XmlRootAttribute(), "default");
            }

            public string Serialize(XmlSerializationProject.Person person)
            {
                return Serialize(new Person(person));
            }

            public string Serialize(Person person)
            {
                string Output = null;
                var Stream = new MemoryStream();
                var Encoding = new UTF8Encoding(false, true);

                using (var Writer = new XmlTextWriter(Stream, Encoding))
                {
                    Writer.Formatting = Formatting.Indented;
                    PersonSerializer.Serialize(Writer, person);
                    Output = Encoding.GetString(Stream.ToArray());
                }
                Stream.Dispose();
                return Output;
            }
        }
    }
}