[英]C# XML serialization override Type of IXmlSerializable Class
我想serialize
一个List<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指出的那样,使用“代理”类是做我想要的最简单的方法。 但正如我所说,我需要动态更改Person类型,这意味着我不能使用属性标签。
所以我仍然在我的最终设计中使用XmlAttributeOverrides
,这里是:
代理List<Person>
类 (与没有属性标记的@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对此表示感谢,您的答案非常有帮助且内容丰富,我学到了很多东西。 我不能赞成你,但我希望社区能做到!
获取所需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
的需要。 或者,您可以使用XmlAttributeOverrides
和XmlAttributes.XmlElements
动态指定EmployeeList
的XML名称。
也就是说,当您尝试将[XmlType]
应用于同时实现IXmlSerializable
的类型时抛出InvalidOperationException
的原因是XmlSerializer
需要通过完全不同的机制返回类型名称,即在一个中指定的XmlSchemaProviderAttribute.MethodName
方法。 [XmlSchemaProvider]
属性。
当[XmlSchemaProvider]
应用于IXmlSerializable
类型时, XmlSerializer
将查找该类型的公共静态方法,该方法的名称在属性构造函数中指定,并具有以下签名:
public static XmlQualifiedName GetSchemaMethod(XmlSchemaSet xs)
{
}
这种方法的目的有两个:
在序列化类型的实例时,它应该使用期望的模式填充XmlSchemaSet
。 通过测试,我发现它必须填充有效的东西 。 它不能只是留空,否则会抛出异常。
(我不知道XmlSerializer
在序列化时实际验证模式的程度。通过xsd.exe
导出模式信息时也会调用该方法。)
它应该返回该类型的XML类型名称。
这似乎是微软抛出您所看到的异常的原因:由于架构属性提供程序应该返回类型名称,因此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<Person>
序列化为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
属性。 看来微软从未实现过这样的功能。 因此,如果你想进一步追求这个设计,你需要做一些kludgy:在创建覆盖序列化器时暂时覆盖GetSchemaMethod()
的返回。 要记住两件事:
在引擎盖下, XmlSerializer
通过创建动态程序集来工作。 如果使用new XmlSerializer(Type)
或new XmlSerializer(Type, String)
构造XmlSerializer
,则.Net将缓存程序集并在第二次构造序列化程序时重用它。
因此,在使用其中任何一个构造序列化程序时尝试临时覆盖GetSchemaMethod()
的返回将失败或产生意外结果。
否则,动态程序集不会被缓存,因此您的代码必须手动缓存序列化程序或导致严重的资源泄漏。 请参阅使用StreamReader和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);
但正如您所看到的,这比使用最初显示的代理更复杂。
示例小提琴显示两个选项。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.