【问题标题】:C# XML serialization override Type of IXmlSerializable ClassC# XML 序列化覆盖 IXmlSerializable 类的类型
【发布时间】:2016-06-30 10:08:03
【问题描述】:

最初的问题

我想 serializeList<IXmlSerializable> 动态更改 IXmlSerializable 类的 XmlType(所以我不能使用属性标签来做到这一点)

我尝试使用 XmlAttributeOverrides 来做到这一点,但到目前为止没有成功。

以下是说明问题的示例代码:
IXmlSerializable 类(来自MSDN):

public class Person : IXmlSerializable
{
    // Private state
    private string personName;


    // Constructors
    public Person(string name)
    {
        personName = name;
    }

    public Person()
    {
        personName = null;
    }


    // Xml Serialization Infrastructure
    public void WriteXml(XmlWriter writer)
    {
        writer.WriteString(personName);
    }

    public void ReadXml(XmlReader reader)
    {
        personName = reader.ReadString();
    }

    public XmlSchema GetSchema()
    {
        return (null);
    }


    // Print
    public override string ToString()
    {
        return (personName);
    }
}

测试类(使用控制台输出):

class Program
{
    static void Main(string[] args)
    {
        List<Person> lPersonList = new List<Person> {
            new Person("First"),
            new Person("Second"),
            new Person("Third")
        };
        XmlAttributeOverrides lOverrides = new XmlAttributeOverrides();
        XmlAttributes lAttributes = new XmlAttributes { XmlType = new XmlTypeAttribute("Employee") };
        lOverrides.Add(typeof(Person), lAttributes);

        XmlSerializer lSerialiser = new XmlSerializer(typeof(List<Person>), lOverrides, null, new XmlRootAttribute("Employees"), null);
        XmlSerializerNamespaces lNamespaces = new XmlSerializerNamespaces();
        lNamespaces.Add("", "");
        lSerialiser.Serialize(Console.Out, lPersonList, lNamespaces);

        System.Console.WriteLine("Enter any key to close.");
        System.Console.ReadKey();
    }
}

这是我想要的:

<Employees>
<Employee>First</Employee>
<Employee>Second</Employee>
<Employee>Third</Employee>
</Employees>

但我在运行时收到此错误:

System.InvalidOperationException:只能为 Person 类型指定 XmlRoot 属性。请使用 XmlSchemaProviderAttribute 指定架构类型。

注意当我的Person类没有实现IXmlSerializable时,一切正常...

有人可以帮我吗?


选择的解决方案(基于@dbc answer

正如@dbc 指出的那样,使用“代理”类是做我想做的最简单的方法。但正如我所说,我需要动态更改 Person 类型,这意味着我不能使用属性标签。
所以我仍然在我的最终设计中使用XmlAttributeOverrides,这里是:

代理List&lt;Person&gt;Class(与不带属性标签的@dbc相同):

public class EmployeesListSurrogate
{
    public List<Person> EmployeeList { get; set; }

    public static implicit operator List<Person>(EmployeesListSurrogate surrogate)
    {
        return surrogate == null ? null : surrogate.EmployeeList;
    }

    public static implicit operator EmployeesListSurrogate(List<Person> employees)
    {
        return new EmployeesListSurrogate { EmployeeList = employees };
    }
}

使用代理的测试类:

class Program
{
    static void Main(string[] args)
    {
        List<Person> lPersonList = new List<Person> {
            new Person("First"),
            new Person("Second"),
            new Person("Third")
        };

        XmlAttributeOverrides lOverrides = new XmlAttributeOverrides();
        XmlAttributes lEmployeesListAttributes = new XmlAttributes { XmlRoot = new XmlRootAttribute("Employees") };
        lOverrides.Add(typeof(EmployeesListSurrogate), lEmployeesListAttributes);
        XmlAttributes lEmployeeAttributes = new XmlAttributes { XmlElements = { new XmlElementAttribute("Employee") } };
        lOverrides.Add(typeof(EmployeesListSurrogate), "EmployeeList", lEmployeeAttributes);

        XmlSerializer lSerializer = new XmlSerializer(typeof(EmployeesListSurrogate), lOverrides);
        XmlSerializerNamespaces lNamespaces = new XmlSerializerNamespaces();
        lNamespaces.Add("", "");
        lSerializer.Serialize(Console.Out, (EmployeesListSurrogate)lPersonList, lNamespaces);
    }
}

我想非常感谢@dbc 来结束这一切,您的回答非常有帮助且内容丰富,我学到了很多东西。我不能投票给你,但我希望社区会这样做!

【问题讨论】:

    标签: c# .net xml-serialization xmlserializer ixmlserializable


    【解决方案1】:

    获取所需 XML 的最简单方法是序列化“代理”类,如下所示:

    [XmlRoot("Employees")]
    public class EmployeesListSurrogate
    {
        [XmlElement("Employee")]
        public List<Person> EmployeeList { get; set; }
    
        public static implicit operator List<Person>(EmployeesListSurrogate surrogate)
        {
            return surrogate == null ? null : surrogate.EmployeeList;
        }
    
        public static implicit operator EmployeesListSurrogate(List<Person> employees)
        {
            return new EmployeesListSurrogate { EmployeeList = employees };
        }
    }
    

    这完全消除了对XmlAttributeOverrides 的需求。或者您可以使用XmlAttributeOverridesXmlAttributes.XmlElements 动态指定EmployeeList 的XML 名称。

    话虽如此,当您尝试将[XmlType] 应用于也实现IXmlSerializable 的类型时,InvalidOperationException 被抛出的原因是XmlSerializer 需要通过完全不同的机制返回类型名称,即在[XmlSchemaProvider] 属性中指定的XmlSchemaProviderAttribute.MethodName 方法。

    [XmlSchemaProvider] 应用于IXmlSerializable 类型时,XmlSerializer 将查找其名称在属性构造函数中指定并具有以下签名的类型的公共静态方法:

        public static XmlQualifiedName GetSchemaMethod(XmlSchemaSet xs)
        {
        }
    

    这种方法的目的是双重的:

    1. 当序列化该类型的实例时,它应该用预期的模式填充XmlSchemaSet。通过测试,我发现它必须用一些有效的东西来填充。不能只留空,否则会抛出异常。

      (我不知道XmlSerializer在序列化时实际上在多大程度上验证了架构。通过xsd.exe导出架构信息时也会调用该方法。)

    2. 它应该返回该类型的 XML 类型名称。

      这似乎是 Microsoft 抛出您所看到的异常的原因:由于架构属性提供程序应该返回类型名称,XmlType 属性将发生冲突。

    因此,如果我将您的 Person 类修改如下:

    [XmlSchemaProvider("GetSchemaMethod")]
    public class Person : IXmlSerializable
    {
        // Private state
        private string personName;
    
        // Constructors
        public Person(string name)
        {
            personName = name;
        }
    
        public Person()
        {
            personName = null;
        }
    
        // This is the method named by the XmlSchemaProviderAttribute applied to the type.
        public static XmlQualifiedName GetSchemaMethod(XmlSchemaSet xs)
        {
            string EmployeeSchema = @"<?xml version=""1.0"" encoding=""utf-16""?>
    <xs:schema elementFormDefault=""qualified"" xmlns:xs=""http://www.w3.org/2001/XMLSchema"">
      <xs:import namespace=""http://www.w3.org/2001/XMLSchema"" />
      <xs:element name=""Employee"" nillable=""true"" type=""Employee"" />
      <xs:complexType name=""Employee"" mixed=""true"">
      <xs:sequence>
        <xs:any />
      </xs:sequence>
      </xs:complexType>
    </xs:schema>";
    
            using (var textReader = new StringReader(EmployeeSchema))
            using (var schemaSetReader = System.Xml.XmlReader.Create(textReader))
            {
                xs.Add("", schemaSetReader);
            }
            return new XmlQualifiedName("Employee");
        }
    
        // Xml Serialization Infrastructure
        public void WriteXml(XmlWriter writer)
        {
            writer.WriteString(personName);
        }
    
        public void ReadXml(XmlReader reader)
        {
            reader.MoveToContent();
            var isEmpty = reader.IsEmptyElement;
            reader.ReadStartElement();
            if (!isEmpty)
            {
                personName = reader.ReadContentAsString();
                reader.ReadEndElement();
            }
        }
    
        public XmlSchema GetSchema()
        {
            return (null);
        }
    
        // Print
        public override string ToString()
        {
            return (personName);
        }
    }
    

    并将您的 List&lt;Person&gt; 序列化为 XML,我得到以下结果:

    <ArrayOfEmployee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
        <Employee>First</Employee>
        <Employee>Second</Employee>
        <Employee>Third</Employee>
    </ArrayOfEmployee>
    

    如您所见,Person 的 XML 类型名称已成功指定。

    但是,您希望通过XmlAttributeOverrides动态覆盖Person 的XML 类型名称,而不是将其设置为编译类型。为此,似乎有必要在XmlAttributes 中指定XmlSchemaProviderAttribute。不幸的是,XmlAttributes 中没有 XmlSchemaProvider 属性。 微软似乎从未实现过这样的功能。因此,如果您想进一步追求这种设计,您将需要做一些笨拙的事情:在创建覆盖序列化程序时临时覆盖GetSchemaMethod() 的返回。要记住两件事:

    1. 在后台,XmlSerializer 通过创建动态程序集来工作。如果您使用new XmlSerializer(Type)new XmlSerializer(Type, String) 构造XmlSerializer,那么.Net 将缓存该程序集并在第二次构造序列化程序时重用它。

      因此,在使用其中任何一个构造序列化程序时尝试临时覆盖 GetSchemaMethod() 的返回将失败或产生意外结果。

    2. 否则动态程序集不会缓存,因此您的代码必须手动缓存序列化程序,否则会出现严重的资源泄漏。见Memory Leak using StreamReader and XmlSerializer

      在这些情况下,暂时覆盖 GetSchemaMethod() 的返回可能会起作用。

    话虽如此,下面会生成您需要的 XML:

    [XmlSchemaProvider("GetSchemaMethod")]
    public class Person : IXmlSerializable
    {
        // Private state
        private string personName;
    
        // Constructors
        public Person(string name)
        {
            personName = name;
        }
    
        public Person()
        {
            personName = null;
        }
    
        [ThreadStatic]
        static string personXmlTypeName;
    
        const string defaultXmlTypeName = "Person";
    
        static string PersonXmlTypeName
        {
            get
            {
                if (personXmlTypeName == null)
                    personXmlTypeName = defaultXmlTypeName;
                return personXmlTypeName;
            }
            set
            {
                personXmlTypeName = value;
            }
        }
    
        public static IDisposable PushXmlTypeName(string xmlTypeName)
        {
            return new PushValue<string>(xmlTypeName, () => PersonXmlTypeName, val => PersonXmlTypeName = val);
        }
    
        // This is the method named by the XmlSchemaProviderAttribute applied to the type.
        public static XmlQualifiedName GetSchemaMethod(XmlSchemaSet xs)
        {
            string EmployeeSchemaFormat = @"<?xml version=""1.0"" encoding=""utf-16""?>
                <xs:schema elementFormDefault=""qualified"" xmlns:xs=""http://www.w3.org/2001/XMLSchema"">
                  <xs:import namespace=""http://www.w3.org/2001/XMLSchema"" />
                  <xs:element name=""{0}"" nillable=""true"" type=""{0}"" />
                  <xs:complexType name=""{0}"" mixed=""true"">
                  <xs:sequence>
                    <xs:any />
                  </xs:sequence>
                  </xs:complexType>
                </xs:schema>";
            var EmployeeSchema = string.Format(EmployeeSchemaFormat, PersonXmlTypeName);
    
            using (var textReader = new StringReader(EmployeeSchema))
            using (var schemaSetReader = System.Xml.XmlReader.Create(textReader))
            {
                xs.Add("", schemaSetReader);
            }
            return new XmlQualifiedName(PersonXmlTypeName);
        }
    
        // Xml Serialization Infrastructure
        public void WriteXml(XmlWriter writer)
        {
            writer.WriteString(personName);
        }
    
        public void ReadXml(XmlReader reader)
        {
            reader.MoveToContent();
            var isEmpty = reader.IsEmptyElement;
            reader.ReadStartElement();
            if (!isEmpty)
            {
                personName = reader.ReadContentAsString();
                reader.ReadEndElement();
            }
        }
    
        public XmlSchema GetSchema()
        {
            return (null);
        }
    
        // Print
        public override string ToString()
        {
            return (personName);
        }
    }
    
    public struct PushValue<T> : IDisposable
    {
        Action<T> setValue;
        T oldValue;
    
        public PushValue(T value, Func<T> getValue, Action<T> setValue)
        {
            if (getValue == null || setValue == null)
                throw new ArgumentNullException();
            this.setValue = setValue;
            this.oldValue = getValue();
            setValue(value);
        }
    
        #region IDisposable Members
    
        // By using a disposable struct we avoid the overhead of allocating and freeing an instance of a finalizable class.
        public void Dispose()
        {
            if (setValue != null)
                setValue(oldValue);
        }
    
        #endregion
    }
    
    public static class PersonEmployeeListSerializerFactory
    {
        static Dictionary<Tuple<string, string>, XmlSerializer> serializers;
        static object padlock = new object();
    
        static PersonEmployeeListSerializerFactory()
        {
            serializers = new Dictionary<Tuple<string, string>, XmlSerializer>();
        }
    
        public static XmlSerializer GetSerializer(string rootName, string personName)
        {
            lock (padlock)
            {
                XmlSerializer serializer;
                var key = Tuple.Create(rootName, personName);
                if (!serializers.TryGetValue(key, out serializer))
                {
                    using (Person.PushXmlTypeName(personName))
                    {
                        var lOverrides = new XmlAttributeOverrides();
                        //var lAttributes = new XmlAttributes();
                        //lOverrides.Add(typeof(Person), lAttributes);
    
                        serializers[key] = serializer = new XmlSerializer(typeof(List<Person>), lOverrides, new Type[0], new XmlRootAttribute(rootName), null);
                    }
                }
                return serializer;
            }
        }
    }
    

    那就做吧

    var lSerialiser = PersonEmployeeListSerializerFactory.GetSerializer("Employees", "Employee");
    
    var lNamespaces = new XmlSerializerNamespaces();
    lNamespaces.Add("", "");
    
    var sb = new StringBuilder();
    using (var writer = new StringWriter(sb))
        lSerialiser.Serialize(writer, lPersonList, lNamespaces);
    
    Console.WriteLine(sb);
    

    但正如您所见,这比使用最初显示的代理要复杂得多。

    示例fiddle 显示了这两个选项。

    【讨论】:

      猜你喜欢
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 2012-06-22
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 2017-01-26
      相关资源
      最近更新 更多