我有一个继承的 C# 类。我已经成功地“构建”了该对象。但我需要将对象序列化为 XML。有简单的方法吗？
看起来该类已设置为序列化，但我不确定如何获取 XML 表示形式。我的类定义如下所示：
[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.0.30319.1")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true, Namespace = "http://www.domain.com/test")]
[System.Xml.Serialization.XmlRootAttribute(Namespace = "http://www.domain.com/test", IsNullable = false)]
public partial class MyObject
{
...
}
这是我认为我可以做的，但它不起作用：
MyObject o = new MyObject();
// Set o properties
string xml = o.ToString();
如何获取该对象的 XML 表示形式？
您必须使用 XmlSerializer 进行 XML 序列化。以下是示例片段。
XmlSerializer xsSubmit = new XmlSerializer(typeof(MyObject));
var subReq = new MyObject();
var xml = "";
using(var sww = new StringWriter())
{
using(XmlWriter writer = XmlWriter.Create(sww))
{
xsSubmit.Serialize(writer, subReq);
xml = sww.ToString(); // Your XML
}
}
根据 @kiquenet 对泛型类的请求：
public class MySerializer<T> where T : class
{
public static string Serialize(T obj)
{
XmlSerializer xsSubmit = new XmlSerializer(typeof(T));
using (var sww = new StringWriter())
{
using (XmlTextWriter writer = new XmlTextWriter(sww) { Formatting = Formatting.Indented })
{
xsSubmit.Serialize(writer, obj);
return sww.ToString();
}
}
}
}
用途：
string xmlMessage = MySerializer<MyClass>.Serialize(myObj);
我修改了我的以返回字符串，而不是使用如下所示的 ref 变量。
public static string Serialize<T>(this T value)
{
if (value == null)
{
return string.Empty;
}
try
{
var xmlserializer = new XmlSerializer(typeof(T));
var stringWriter = new StringWriter();
using (var writer = XmlWriter.Create(stringWriter))
{
xmlserializer.Serialize(writer, value);
return stringWriter.ToString();
}
}
catch (Exception ex)
{
throw new Exception("An error occurred", ex);
}
}
它的用法是这样的：
var xmlString = obj.Serialize();
可以将以下函数复制到任何对象，以使用 System.Xml 命名空间添加 XML 保存函数。
/// <summary>
/// Saves to an xml file
/// </summary>
/// <param name="FileName">File path of the new xml file</param>
public void Save(string FileName)
{
using (var writer = new System.IO.StreamWriter(FileName))
{
var serializer = new XmlSerializer(this.GetType());
serializer.Serialize(writer, this);
writer.Flush();
}
}
要从保存的文件创建对象，请添加以下函数并将 [ObjectType] 替换为要创建的对象类型。
/// <summary>
/// Load an object from an xml file
/// </summary>
/// <param name="FileName">Xml file name</param>
/// <returns>The object created from the xml file</returns>
public static [ObjectType] Load(string FileName)
{
using (var stream = System.IO.File.OpenRead(FileName))
{
var serializer = new XmlSerializer(typeof([ObjectType]));
return serializer.Deserialize(stream) as [ObjectType];
}
}
延伸类：
using System.IO;
using System.Xml;
using System.Xml.Serialization;
namespace MyProj.Extensions
{
public static class XmlExtension
{
public static string Serialize<T>(this T value)
{
if (value == null) return string.Empty;
var xmlSerializer = new XmlSerializer(typeof(T));
using (var stringWriter = new StringWriter())
{
using (var xmlWriter = XmlWriter.Create(stringWriter,new XmlWriterSettings{Indent = true}))
{
xmlSerializer.Serialize(xmlWriter, value);
return stringWriter.ToString();
}
}
}
}
}
用途：
Foo foo = new Foo{MyProperty="I have been serialized"};
string xml = foo.Serialize();
只需在要使用扩展方法的文件中引用保存扩展方法的命名空间，它就会起作用（在我的示例中，它将是：
using MyProj.Extensions;请注意，如果您想让扩展方法仅特定于特定类（例如，
FooTpublic static string Serialize(this Foo value){...}您可以使用如下函数从任何对象获取序列化的 XML。
public static bool Serialize<T>(T value, ref string serializeXml)
{
if (value == null)
{
return false;
}
try
{
XmlSerializer xmlserializer = new XmlSerializer(typeof(T));
StringWriter stringWriter = new StringWriter();
XmlWriter writer = XmlWriter.Create(stringWriter);
xmlserializer.Serialize(writer, value);
serializeXml = stringWriter.ToString();
writer.Close();
return true;
}
catch (Exception ex)
{
return false;
}
}
您可以从客户端调用它。
以上所有赞成的答案都是正确的。这只是最简单的版本：
private string Serialize(Object o)
{
using (var writer = new StringWriter())
{
new XmlSerializer(o.GetType()).Serialize(writer, o);
return writer.ToString();
}
}
要序列化对象，请执行以下操作：
using (StreamWriter myWriter = new StreamWriter(path, false))
{
XmlSerializer mySerializer = new XmlSerializer(typeof(your_object_type));
mySerializer.Serialize(myWriter, objectToSerialize);
}
还请记住，要使 XmlSerializer 工作，您需要一个无参数构造函数。
我将从 Ben Gripka 的复制答案开始：
public void Save(string FileName)
{
using (var writer = new System.IO.StreamWriter(FileName))
{
var serializer = new XmlSerializer(this.GetType());
serializer.Serialize(writer, this);
writer.Flush();
}
}
我之前使用过这段代码。但现实证明这个解决方案是有点问题的。通常大多数程序员只是在保存时序列化设置并在加载时反序列化设置。这是一个乐观的情况。一旦序列化失败，由于某种原因，文件被部分写入，XML文件不完整，无效。因此，XML 反序列化不起作用，您的应用程序可能会在启动时崩溃。如果文件不大，我建议首先将对象序列化为
MemoryStreampublic void Save(string fileName)
{
//first serialize the object to memory stream,
//in case of exception, the original file is not corrupted
using (MemoryStream ms = new MemoryStream())
{
var writer = new System.IO.StreamWriter(ms);
var serializer = new XmlSerializer(this.GetType());
serializer.Serialize(writer, this);
writer.Flush();
//if the serialization succeed, rewrite the file.
File.WriteAllBytes(fileName, ms.ToArray());
}
}
现实场景中的反序列化应该与损坏的序列化文件一起计算，这种情况有时会发生。 Ben Gripka 提供的 Load 功能很好。
public static [ObjectType] Load(string fileName)
{
using (var stream = System.IO.File.OpenRead(fileName))
{
var serializer = new XmlSerializer(typeof([ObjectType]));
return serializer.Deserialize(stream) as [ObjectType];
}
}
它可能会被一些恢复场景所包裹。它适用于设置文件或其他在出现问题时可以删除的文件。
public static [ObjectType] LoadWithRecovery(string fileName)
{
try
{
return Load(fileName);
}
catch(Excetion)
{
File.Delete(fileName); //delete corrupted settings file
return GetFactorySettings();
}
}
比调用类的
ToString这是一个简单的插入函数，您可以使用它来序列化任何类型的对象。它返回一个包含序列化 XML 内容的字符串：
public string SerializeObject(object obj)
{
System.Xml.XmlDocument xmlDoc = new System.Xml.XmlDocument();
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(obj.GetType());
using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) {
serializer.Serialize(ms, obj);
ms.Position = 0;
xmlDoc.Load(ms);
return xmlDoc.InnerXml;
}
}
基于上述解决方案，这里有一个扩展类，您可以使用它来序列化和反序列化任何对象。任何其他 XML 属性都取决于您。
就像这样使用它：
string s = new MyObject().Serialize(); // to serialize into a string
MyObject b = s.Deserialize<MyObject>();// deserialize from a string
internal static class Extensions
{
public static T Deserialize<T>(this string value)
{
var xmlSerializer = new XmlSerializer(typeof(T));
return (T)xmlSerializer.Deserialize(new StringReader(value));
}
public static string Serialize<T>(this T value)
{
if (value == null)
return string.Empty;
var xmlSerializer = new XmlSerializer(typeof(T));
using (var stringWriter = new StringWriter())
{
using (var xmlWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings { Indent = true }))
{
xmlSerializer.Serialize(xmlWriter, value);
return stringWriter.ToString();
}
}
}
}
我有一种使用 C# 将对象序列化为 XML 的简单方法，它效果很好并且可重用性很高。我知道这是一个较旧的帖子，但我想发布此帖子，因为有人可能会发现这对他们有帮助。
这是我如何调用该方法：
var objectToSerialize = new MyObject();
var xmlString = objectToSerialize.ToXmlString();
这是完成这项工作的类：
注意：由于这些是扩展方法，因此它们需要位于静态类中。
using System.IO;
using System.Xml.Serialization;
public static class XmlTools
{
public static string ToXmlString<T>(this T input)
{
using (var writer = new StringWriter())
{
input.ToXml(writer);
return writer.ToString();
}
}
private static void ToXml<T>(this T objectToSerialize, StringWriter writer)
{
new XmlSerializer(typeof(T)).Serialize(writer, objectToSerialize);
}
}
我的工作代码。返回 utf8 xml 启用空命名空间。
// override StringWriter
public class Utf8StringWriter : StringWriter
{
public override Encoding Encoding => Encoding.UTF8;
}
private string GenerateXmlResponse(Object obj)
{
Type t = obj.GetType();
var xml = "";
using (StringWriter sww = new Utf8StringWriter())
{
using (XmlWriter writer = XmlWriter.Create(sww))
{
var ns = new XmlSerializerNamespaces();
// add empty namespace
ns.Add("", "");
XmlSerializer xsSubmit = new XmlSerializer(t);
xsSubmit.Serialize(writer, obj, ns);
xml = sww.ToString(); // Your XML
}
}
return xml;
}
示例返回响应 Yandex api 付款 Aviso url：
<?xml version="1.0" encoding="utf-8"?><paymentAvisoResponse xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" performedDatetime="2017-09-01T16:22:08.9747654+07:00" code="0" shopId="54321" invoiceId="12345" orderSumAmount="10643" />
string FilePath = ConfigurationReader.FileLocation; //Getting path value from web.config
XmlSerializer serializer = new XmlSerializer(typeof(Devices)); //typeof(object)
MemoryStream memStream = new MemoryStream();
serializer.Serialize(memStream, lstDevices);//lstdevices : I take result as a list.
FileStream file = new FileStream(folderName + "\\Data.xml", FileMode.Create, FileAccess.ReadWrite); //foldername:Specify the path to store the xml file
memStream.WriteTo(file);
file.Close();
您可以创建结果并将其作为 xml 文件存储在所需位置。
或者您可以将此方法添加到您的对象中：
public void Save(string filename)
{
var ser = new XmlSerializer(this.GetType());
using (var stream = new FileStream(filename, FileMode.Create))
ser.Serialize(stream, this);
}
以下是有助于将 C# 对象序列化为 xml 的基本代码：
using System;
public class clsPerson
{
public string FirstName;
public string MI;
public string LastName;
}
class class1
{
static void Main(string[] args)
{
clsPerson p=new clsPerson();
p.FirstName = "Jeff";
p.MI = "A";
p.LastName = "Price";
System.Xml.Serialization.XmlSerializer x = new System.Xml.Serialization.XmlSerializer(p.GetType());
x.Serialize(Console.Out, p);
Console.WriteLine();
Console.ReadLine();
}
}
public string ObjectToXML(object input)
{
try
{
var stringwriter = new System.IO.StringWriter();
var serializer = new XmlSerializer(input.GetType());
serializer.Serialize(stringwriter, input);
return stringwriter.ToString();
}
catch (Exception ex)
{
if (ex.InnerException != null)
ex = ex.InnerException;
return "Could not convert: " + ex.Message;
}
}
//Usage
var res = ObjectToXML(obj)
您需要使用以下类：
using System.IO;
using System.Xml;
using System.Xml.Serialization;
这是一个通用对象序列化器：
using System.IO;
using System.Text;
using System.Xml.Schema;
namespace System.Xml.Serialization
{
/// <summary>
/// Serializes and deserializes <typeparamref name="T"/> objects into XML documents.
/// Allows you to control the process of encoding objects in XML.
/// </summary>
/// <typeparam name="T">Object type.</typeparam>
public static class XmlSerializer<T>
{
private static readonly XmlSerializer _serializer = new XmlSerializer(typeof(T));
private static readonly XmlWriterSettings _defaultWriterSettings = new XmlWriterSettings
{
CheckCharacters = false
CloseOutput=false
ConformanceLevel = ConformanceLevel.Auto,
Encoding = Encoding.UTF8,
indent=true,
IndentChars = "\t",
NamespaceHandling = NamespaceHandling.OmitDuplicates,
NewLineChars = "\r\n",
NewLineHandling = NewLineHandling.Replace,
NewLineOnAttributes = false,
OmitXmlDeclaration = false
};
private static readonly XmlReaderSettings _defaultReaderSettings = new XmlReaderSettings
{
CheckCharacters = false
CloseInput=false
ConformanceLevel = ConformanceLevel.Auto,
DtdProcessing = DtdProcessing.Prohibit,
IgnoreComments = true,
IgnoreProcessingInstructions = true,
IgnoreWhitespace=true,
LineNumberOffset = 0
LinePositionOffset = 0
MaxCharactersFromEntities = 0,
MaxCharactersInDocument = 0,
NameTable = null
// Schemas = null, // ???
ValidationFlags = XmlSchemaValidationFlags.None,
ValidationType = ValidationType. None,
XmlResolver = null
};
/// <summary>
/// Default character encoding.
/// </summary>
public static Encoding DefaultEncoding => Encoding.UTF8;
/// <summary>
/// Default settings for the <see cref="XmlWriter" /> instance being created.
/// </summary>
public static XmlWriterSettings DefaultXmlWriterSettings => _defaultWriterSettings.Clone();
/// <summary>
/// Default settings for the <see cref="XmlReader" /> instance that is created.
/// </summary>
public static XmlReaderSettings DefaultXmlReaderSettings => _defaultReaderSettings.Clone();
/// <summary>
/// Serializes the given <typeparamref name="T"/> and returns the XML document as a string.
/// </summary>
/// <param name="o">
/// Instance <see cref="object" /> to serialize.
/// </param>
public static string Serialize(T o)
{
StringBuilder sb = new StringBuilder();
using (XmlWriter xmlWriter = XmlWriter.Create(sb))
_serializer.Serialize(xmlWriter, o, (XmlSerializerNamespaces)null);
return sb.ToString();
}
/// <summary>
/// Serializes the given <typeparamref name="T"/> and returns the XML document as a string.
/// </summary>
/// <param name="o">
/// Instance <see cref="object" /> to serialize.
/// </param>
/// <param name="settings">
/// Settings for the new <see cref="XmlWriter" /> instance. If <see langword="null"/> is specified,
/// settings are used <see cref="DefaultXmlWriterSettings"/>.
/// </param>
public static string Serialize(T o, XmlWriterSettings settings)
{
if (settings == null) settings = _defaultWriterSettings;
StringBuilder sb = new StringBuilder();
using (XmlWriter xmlWriter = XmlWriter.Create(sb, settings))
_serializer.Serialize(xmlWriter, o, (XmlSerializerNamespaces)null);
return sb.ToString();
}
/// <summary>
/// Serializes the given <typeparamref name="T"/> and writes the XML document to a file using the given <see cref="TextWriter" />.
/// </summary>
/// <param name="textWriter">
/// <see cref="TextWriter" /> Used to write an XML document.
/// </param>
/// <param name="o">
/// Instance <see cref="object" /> to serialize.
/// </param>
public static void Serialize(TextWriter textWriter, T o)
{
using (XmlWriter xmlWriter = XmlWriter.Create(textWriter))
_serializer.Serialize(textWriter, o, (XmlSerializerNamespaces)null);
}
/// <summary>
/// Serializes the given <typeparamref name="T"/> and writes the XML document to a file using the given <see cref="TextWriter" />.
/// </summary>
/// <param name="textWriter">
/// <see cref="TextWriter" /> Used to write an XML document.
/// </param>
/// <param name="o">
/// Instance <see cref="object" /> to serialize.
/// </param>
/// <param name="settings">
/// Settings for the new <see cref="XmlWriter" /> instance. If <see langword="null"/> is specified,
/// settings are used <see cref="DefaultXmlWriterSettings"/>.
/// </param>
public static void Serialize(TextWriter textWriter, T o, XmlWriterSettings settings)
{
if (settings == null) settings = _defaultWriterSettings;
using (XmlWriter xmlWriter = XmlWriter.Create(textWriter, settings))
_serializer.Serialize(xmlWriter, o, (XmlSerializerNamespaces)null);
}
/// <summary>
/// Serializes the given <typeparamref name="T"/> and writes the XML document to a file using the given <see cref="TextWriter" /> and references to the given namespaces.
/// </summary>
/// <param name="textWriter">
/// <see cref="TextWriter" /> Used to write an XML document.
/// </param>
/// <param name="o">
/// Instance <see cref="object" /> to serialize.
/// </param>
/// <param name="namespaces">
/// <see cref="XmlSerializerNamespaces" /> Contains the namespaces for the generated XML document.
/// </param>
/// <exception cref="InvalidOperationException">
/// An error occurred during serialization.
/// The original exception is accessible using the <see cref="P:System.Exception.InnerException" /> property.
/// </exception>
public static void Serialize(TextWriter textWriter, T o, XmlSerializerNamespaces namespaces)
{
using (XmlWriter xmlWriter = XmlWriter.Create(textWriter))
_serializer.Serialize(xmlWriter, o, namespaces);
}
/// <summary>
/// Serializes the given <typeparamref name="T"/> and writes the XML document to a file using the given <see cref="TextWriter" /> and references to the given namespaces.
/// </summary>
/// <param name="textWriter">
/// <see cref="TextWriter" /> Used to write an XML document.
/// </param>
/// <param name="o">
/// Instance <see cref="object" /> to serialize.
/// </param>
/// <param name="namespaces">
/// <see cref="XmlSerializerNamespaces" /> Contains the namespaces for the generated XML document.
/// </param>
/// <param name="settings">
/// Settings for the new <see cref="XmlWriter" /> instance. If <see langword="null"/> is specified,
/// settings are used <see cref="DefaultXmlWriterSettings"/>.
/// </param>
/// <exception cref="InvalidOperationException">
/// An error occurred during serialization.
/// The original exception is accessible using the <see cref="P:System.Exception.InnerException" /> property.
/// </exception>
public static void Serialize(TextWriter textWriter, T o, XmlSerializerNamespaces namespaces, XmlWriterSettings settings)
{
if (settings == null) settings = _defaultWriterSettings;
using (XmlWriter xmlWriter = XmlWriter.Create(textWriter, settings))
_serializer.Serialize(xmlWriter, o, namespaces);
}
/// <summary>
/// Serializes the given <typeparamref name="T"/> and writes the XML document to a file using the given <see cref="Stream" />.
/// </summary>
/// <param name="stream">
/// <see cref="Stream" /> Used to write an XML document.
/// </param>
/// <param name="o">
/// Instance <see cref="object" /> to serialize.
/// </param>
/// <exception cref="InvalidOperationException">
/// An error occurred during serialization.
/// The original exception is accessible using the <see cref="P:System.Exception.InnerException" /> property.
/// </exception>
public static void Serialize(Stream stream, T o)
{
_serializer.Serialize(stream, o, (XmlSerializerNamespaces)null);
}
/// <summary>
/// Serializes the given <typeparamref name="T"/> and writes the XML document to a file using the given <see cref="Stream" />.
/// </summary>
/// <param name="stream">
/// <see cref="Stream" /> Used to write an XML document.
/// </param>
/// <param name="o">
/// Instance <see cref="object" /> to serialize.
/// </param>
/// <param name="settings">
/// Settings for the new <see cref="XmlWriter" /> instance. If <see langword="null"/> is specified,
/// settings are used <see cref="DefaultXmlWriterSettings"/>.
/// </param>
/// <exception cref="InvalidOperationException">
/// An error occurred during serialization.
/// The original exception is accessible using the <see cref="P:System.Exception.InnerException" /> property.
/// </exception>
public static void Serialize(Stream stream, T o, XmlWriterSettings settings)
{
if (settings == null) settings = _defaultWriterSettings;
using (TextWriter writer = new StreamWriter(stream, settings.Encoding))
using (XmlWriter xmlWriter = XmlWriter.Create(writer, settings))
_serializer.Serialize(xmlWriter, o, (XmlSerializerNamespaces) null);
}
/// <summary>
/// Serializes the given <typeparamref name="T"/> and writes the XML document to a file using the given <see cref="Stream" /> refers to the given namespaces.
/// </summary>
/// <param name="stream">
/// <see cref="Stream" /> Used to write an XML document.
/// </param>
/// <param name="o">
/// Instance <see cref="object" /> to serialize.
/// </param>
/// <param name="namespaces">
/// <see cref="XmlSerializerNamespaces" /> The object is referenced.
/// </param>
/// <exception cref="InvalidOperationException">
/// An error occurred during serialization.
/// The original exception is accessible using the <see cref="P:System.Exception.InnerException" /> property.
/// </exception>
public static void Serialize(Stream stream, T o, XmlSerializerNamespaces namespaces)
{
_serializer.Serialize(stream, o, namespaces);
}
/// <summary>
/// Serializes the given <typeparamref name="T"/> and writes the XML document to a file using the given <see cref="Stream" /> refers to the given namespaces.
/// </summary>
/// <param name="stream">
/// <see cref="Stream" /> Used to write an XML document.
/// </param>
/// <param name="o">
/// Instance <see cref="object" /> to serialize.
/// </param>
/// <param name="namespaces">
/// <see cref="XmlSerializerNamespaces" /> The object is referenced.
/// </param>
/// <param name="settings">
/// Settings for the new <see cref="XmlWriter" /> instance. If <see langword="null"/> is specified,
/// settings are used <see cref="DefaultXmlWriterSettings"/>.
/// </param>
/// <exception cref="InvalidOperationException">
/// An error occurred during serialization.
/// The original exception is accessible using the <see cref="P:System.Exception.InnerException" /> property.
/// </exception>
public static void Serialize(Stream stream, T o, XmlSerializerNamespaces namespaces, XmlWriterSettings settings)
{
if (settings == null) settings = _defaultWriterSettings;
using (TextWriter writer = new StreamWriter(stream, settings.Encoding))
using (XmlWriter xmlWriter = XmlWriter.Create(writer, settings))
_serializer.Serialize(xmlWriter, o, namespaces);
}
/// <summary>
/// Serializes the given <typeparamref name="T"/> and writes the XML document to a file using the given <see cref="XmlWriter" />.
/// </summary>
/// <param name="xmlWriter">
/// <see cref="XmlWriter" /> Used to write an XML document.
/// </param>
/// <param name="o">
/// Instance <see cref="object" /> to serialize.
/// </param>
/// <param name="settings">
/// Settings for the new <see cref="XmlWriter" /> instance. If <see langword="null"/> is specified,
/// the settings of the current <see cref="XmlWriter" /> instance are used.
/// </param>
/// <exception cref="InvalidOperationException">
/// An error occurred during serialization.
/// The original exception is accessible using the <see cref="P:System.Exception.InnerException" /> property.
/// </exception>
public static void Serialize(XmlWriter xmlWriter, T o, XmlWriterSettings settings = null)
{
using (XmlWriter writer = settings == null ? xmlWriter : XmlWriter.Create(xmlWriter, settings))
_serializer.Serialize(writer, o, (XmlSerializerNamespaces)null);
}
/// <summary>
/// Serializes the given <typeparamref name="T"/> and writes the XML document to a file using the given <see cref="XmlWriter" /> and references to the given namespaces.
/// </summary>
/// <param name="xmlWriter">
/// <see cref="XmlWriter" /> Used to write an XML document.
/// </param>
/// <param name="o">
/// Instance <see cref="object" /> to serialize.
/// </param>
/// <param name="namespaces">
/// <see cref="XmlSerializerNamespaces" /> The object is referenced.
/// </param>
/// <param name="settings">
/// Settings for the new <see cref="XmlWriter" /> instance. If <see langword="null"/> is specified,
/// the settings of the current <see cref="XmlWriter" /> instance are used.
/// </param>
/// <exception cref="InvalidOperationException">
/// An error occurred during serialization.
/// The original exception is accessible using the <see cref="P:System.Exception.InnerException" /> property.
/// </exception>
public static void Serialize(XmlWriter xmlWriter, T o, XmlSerializerNamespaces namespaces, XmlWriterSettings settings = null)
{
using (XmlWriter writer = settings == null ? xmlWriter : XmlWriter.Create(xmlWriter, settings))
_serializer.Serialize(writer, o, namespaces);
}
/// <summary>
/// Serializes the specified object and writes the XML document to a file using the specified <typeparamref name="T"/> and references the specified namespaces and encoding style.
/// </summary>
/// <param name="xmlWriter">
/// <see cref="XmlWriter" /> Used to write an XML document.
/// </param>
/// <param name="o">Object to serialize.</param>
/// <param name="namespaces">
/// <see cref="XmlSerializerNamespaces" /> The object is referenced.
/// </param>
/// <param name="encodingStyle">
/// The encoding style of the serialized XML.
/// </param>
/// <param name="settings">
/// Settings for the new <see cref="XmlWriter" /> instance. If <see langword="null"/> is specified,
/// the settings of the current <see cref="XmlWriter" /> instance are used.
/// </param>
/// <exception cref="InvalidOperationException">
/// An error occurred during serialization.
/// The original exception is accessible using the <see cref="P:System.Exception.InnerException" /> property.
/// </exception>
public static void Serialize(
XmlWriter xmlWriter,
T o
XmlSerializerNamespaces,
string encodingStyle,
XmlWriterSettings settings = null)
{
using (XmlWriter writer = settings == null ? xmlWriter : XmlWriter.Create(xmlWriter, settings))
_serializer.Serialize(writer, o, namespaces, encodingStyle, (string)null);
}
/// <summary>
/// Serializes the given <typeparamref name="T"/> and writes the XML document to a file using the given <see cref="XmlWriter" />, XML namespaces, and encoding.
/// </summary>
/// <param name="xmlWriter">
/// <see cref="XmlWriter" /> Used to write an XML document.
/// </param>
/// <param name="o">Object to serialize.</param>
/// <param name="namespaces">
/// An instance of <see langword="XmlSerializaerNamespaces" /> containing the namespaces and prefixes used.
/// </param>
/// <param name="encodingStyle">
/// The encoding used in the document.
/// </param>
/// <param name="id">
/// For SOAP encoded messages, a base is used to generate identifier attributes.
/// </param>
/// <param name="settings">
/// Settings for the new <see cref="XmlWriter" /> instance. If <see langword="null"/> is specified,
/// the settings of the current <see cref="XmlWriter" /> instance are used.
/// </param>
public static void Serialize(
XmlWriter xmlWriter,
T o
XmlSerializerNamespaces,
string encodingStyle,
string id,
XmlWriterSettings settings = null)
{
using (XmlWriter writer = settings == null ? xmlWriter : XmlWriter.Create(xmlWriter, settings))
_serializer.Serialize(writer, o, namespaces, encodingStyle, id);
}
/// <summary>
/// Deserializes the XML document contained in the specified string.
/// </summary>
/// settings are used <see cref="DefaultXmlReaderSettings"/>.</param>
/// <returns> The deserialized object <typeparamref name="T"/>. </returns>
public static T Deserialize(string text)
{
using (StringReader reader = new StringReader(text))
using (XmlReader xmlReader = XmlReader.Create(reader))
return (T)_serializer.Deserialize(xmlReader);
}
/// <summary>
/// Deserializes the XML document contained in the specified string.
/// </summary>
/// <param name="text">String containing the XML document.</param>
/// <param name="settings"> Settings for the new <see cref="XmlReader" /> instance. If <see langword="null"/> is specified,
/// settings are used <see cref="DefaultXmlReaderSettings"/>.</param>
/// <returns> The deserialized object <typeparamref name="T"/>. </returns>
public static T Deserialize(string text, XmlReaderSettings settings)
{
if (settings == null) settings = _defaultReaderSettings;
using (StringReader reader = new StringReader(text))
using (XmlReader xmlReader = XmlReader.Create(reader, settings))
return (T)_serializer.Deserialize(xmlReader);
}
/// <summary>
/// Deserializes the XML document contained in the specified <see cref="Stream" />.
/// </summary>
/// <param name="stream">
/// <see cref="Stream" /> Containing the XML document to deserialize.
/// </param>
/// <returns>
/// Deserialized object <typeparamref name="T"/>.
/// </returns>
public static T Deserialize(Stream stream)
{
return (T)_serializer.Deserialize(stream);
}
/// <summary>
/// Deserializes the XML document contained in the specified <see cref="Stream" />.
/// </summary>
/// <param name="stream">
/// <see cref="Stream" /> Containing the XML document to deserialize.
/// </param>
/// <param name="settings">Settings for the new <see cref="XmlReader" /> instance. If <see langword="null"/> is specified,
/// settings are used <see cref="DefaultXmlReaderSettings"/>.</param>
/// <returns>
/// Deserialized object <typeparamref name="T"/>.
/// </returns>
public static T Deserialize(Stream stream, XmlReaderSettings settings)
{
if (settings == null) settings = _defaultReaderSettings;
using(XmlReader xmlReader = XmlReader.Create(stream, settings))
return (T)_serializer.Deserialize(xmlReader);
}
/// <summary>
/// Deserializes the XML document contained in the specified <see cref="TextReader" />.
/// </summary>
/// <param name="textReader">
/// <see cref="TextReader" /> The containing XML document to deserialize.
/// </param>
/// <returns>
/// Deserialized object <typeparamref name="T"/>.
/// </returns>
/// <exception cref="InvalidOperationException">
/// An error occurred during deserialization.
/// The original exception is accessible using the <see cref="P:System.Exception.InnerException" /> property.
/// </exception>
public static T Deserialize(TextReader textReader)
{
return (T) _serializer.Deserialize(textReader);
}
/// <summary>
/// Deserializes the XML document contained in the specified <see cref="TextReader" />.
/// </summary>
/// <param name="textReader">
/// <see cref="TextReader" /> The containing XML document to deserialize.
/// </param>
/// <param name="settings">Settings for the new <see cref="XmlReader" /> instance. If <see langword="null"/> is specified,
/// settings are used <see cref="DefaultXmlReaderSettings"/>.</param>
/// <returns>
/// Deserialized object <typeparamref name="T"/>.
/// </returns>
/// <exception cref="InvalidOperationException">
/// An error occurred during deserialization.
/// The original exception is accessible using the <see cref="P:System.Exception.InnerException" /> property.
/// </exception>
public static T Deserialize(TextReader textReader, XmlReaderSettings settings)
{
if (settings == null) settings = _defaultReaderSettings;
using (XmlReader xmlReader = XmlReader.Create(textReader, settings))
return (T)_serializer.Deserialize(xmlReader);
}
/// <summary>
/// Deserializes the XML document contained in the specified <see cref="XmlReader" />.
/// </summary>
/// <param name="xmlReader">
/// <see cref="XmlReader" /> The containing XML document to deserialize.
/// </param>
/// <param name="settings">Settings for the new <see cref="XmlReader" /> instance. If <see langword="null"/> is specified,
/// current instance settings are used <see cref="XmlReader" />.</param>
/// <returns>
/// Deserialized object <typeparamref name="T"/>.
/// </returns>
/// <exception cref="InvalidOperationException">
/// An error occurred during deserialization.
/// The original exception is accessible using the <see cref="P:System.Exception.InnerException" /> property.
/// </exception>
public static T Deserialize(XmlReader xmlReader, XmlReaderSettings settings = null)
{
using (XmlReader reader = settings == null ? xmlReader : XmlReader.Create(xmlReader, settings))
return (T)_serializer.Deserialize(xmlReader);
}
/// <summary>
/// Deserializes the XML document contained in the specified <see cref="XmlReader" /> and allows you to override events that occur during deserialization.
/// </summary>
/// <param name="xmlReader">
/// <see cref="XmlReader" /> The containing document to deserialize.
/// </param>
/// <param name="events">
/// Class instance <see cref="XmlDeserializationEvents" />.
/// </param>
/// <param name="settings">Settings for the new <see cref="XmlReader" /> instance. If <see langword="null"/> is specified,
/// current instance settings are used <see cref="XmlReader" />.</param>
/// <returns>
/// Deserialized object <typeparamref name="T"/>.
/// </returns>
public static T Deserialize(XmlReader xmlReader, XmlDeserializationEvents events, XmlReaderSettings settings = null)
{
using (XmlReader reader = settings == null ? xmlReader : XmlReader.Create(xmlReader, settings))
return (T)_serializer.Deserialize(reader, (string)null, events);
}
/// <summary>
/// Deserializes the XML document contained in the specified <see cref="XmlReader" /> and encoding style.
/// </summary>
/// <param name="xmlReader">
/// <see cref="XmlReader" /> The containing XML document to deserialize.
/// </param>
/// <param name="encodingStyle">
/// The encoding style of the serialized XML.
/// </param>
/// <param name="settings">Settings for the new <see cref="XmlReader" /> instance. If <see langword="null"/> is specified,
/// current instance settings are used <see cref="XmlReader" />.</param>
/// <returns>The deserialized object.</returns>
/// <exception cref="InvalidOperationException">
/// An error occurred during deserialization.
/// The original exception is accessible using the <see cref="P:System.Exception.InnerException" /> property.
/// </exception>
public static T Deserialize(XmlReader xmlReader, string encodingStyle, XmlReaderSettings settings = null)
{
using (XmlReader reader = settings == null ? xmlReader : XmlReader.Create(xmlReader, settings))
return (T)_serializer.Deserialize(reader, encodingStyle);
}
/// <summary>
/// Deserializes the object using the data contained in the specified <see cref="XmlReader" />.
/// </summary>
/// <param name="xmlReader">
/// An instance of the <see cref="XmlReader" /> class used to read the document.
/// </param>
/// <param name="encodingStyle">Encoding used.</param>
/// <param name="events">
/// Class instance <see cref="XmlDeserializationEvents" />.
/// </param>
/// <param name="settings">Settings for the new <see cref="XmlReader" /> instance. If <see langword="null"/> is specified,
/// current instance settings are used <see cref="XmlReader" />.</param>
/// <returns>The deserialized object <typeparamref name="T"/>.</returns>
public static object Deserialize(
xmlReader xmlReader,
string encodingStyle,
XmlDeserializationEvents events,
XmlReaderSettings settings = null)
{
using (XmlReader reader = settings == null ? xmlReader : XmlReader.Create(xmlReader, settings))
return _serializer.Deserialize(reader, encodingStyle, events);
}
/// <summary>
/// Returns a value indicating whether this <see cref="XmlSerializer" /> can deserialize the specified XML document.
/// </summary>
/// <param name="xmlReader">
/// <see cref="XmlReader" /> Pointing to the document to deserialize.
/// </param>
/// <returns>
/// <see langword="true" /> If this <see cref="XmlSerializer" /> can deserialize an object, <see cref="XmlReader" /> indicates; otherwise, <see langword="false" />.
/// </returns>
public static bool CanDeserialize(XmlReader xmlReader)
{
return _serializer.CanDeserialize(xmlReader);
}
}
}
聚会可能为时已晚，但仅使用用户定义的命名空间进行序列化：
public static string XmlSerialize<T>(this T obj) where T : class
{
Type serialType = typeof(T);
var xsSubmit = new XmlSerializer(serialType);
XmlWriterSettings xws = new XmlWriterSettings() { OmitXmlDeclaration = true, Indent = true };
var Namespaces = new XmlSerializerNamespaces(new XmlQualifiedName[]
{
new XmlQualifiedName(string.Empty, GetXmlNameSpace(serialType) ?? string.Empty )
});
string result = null;
using(var sww = new StringWriter())
using(var writer = XmlWriter.Create(sww, xws))
{
xsSubmit.Serialize(writer, obj, Namespaces);
result = sww.ToString();
}
return result;
);
private static string GetXmlNameSpace(Type target)
{
XmlRootAttribute attribute = (XmlRootAttribute)Attribute.GetCustomAttribute(target, typeof(XmlRootAttribute));
return attribute == null ? null : attribute.Namespace;
}
并在自定义类中定义命名空间
[XmlRoot("IdentityTerminal",Namespace = "http://my-name-space/XMLSchema")]
public class IdentityTerminal
{
}
此代码仅允许使用用户定义的命名空间并忽略默认命名空间。