C# 将对象转换为XML字符串

我从xsd文件的工具xsd.exe获得了一个名为

WebserviceType

的类

现在，我想将

WebServiceType

对象的实例反序列化为字符串。 我该怎么做

MethodCheckType

对象的参数为

WebServiceType

数组

我的第一次尝试就像我序列化了它：使用

XmlSerializer

和

StringWriter

（序列化时我使用了

StringReader

）

这是我序列化

WebServiceType

对象的方法：

XmlSerializer serializer = new XmlSerializer(typeof(MethodCheckType));
        MethodCheckType output = null;
        StringReader reader = null;

        // catch global exception, logg it and throw it
        try
        {
            reader = new StringReader(path);
            output = (MethodCheckType)serializer.Deserialize(reader);
        }
        catch (Exception)
        {
            throw;
        }
        finally
        {
            reader.Dispose();
        }

        return output.WebService;

---

编辑：

---

也许我可以用不同的词来表达：我有一个

MethodCheckType

对象的实例，另一方面，我有一个XML文档，我从中序列化了这个对象。现在我想将这个实例转换为字符串形式的XML文档。在此之后，我必须证明（XML文档的）两个字符串是否相同。我必须这样做，因为我对第一种方法进行了单元测试，在这种方法中，我将XML文档读入

StringReader

，并将其序列化为

MethodCheckType

对象。 这=您的类的实例

public string ToXML()
    {
        using(var stringwriter = new System.IO.StringWriter())
        { 
            var serializer = new XmlSerializer(this.GetType());
            serializer.Serialize(stringwriter, this);
            return stringwriter.ToString();
        }
    }

 public static YourClass LoadFromXMLString(string xmlText)
    {
        using(var stringReader = new System.IO.StringReader(xmlText))
        {
            var serializer = new XmlSerializer(typeof(YourClass ));
            return serializer.Deserialize(stringReader) as YourClass ;
        }
    }

---

我意识到这是一篇非常古老的帖子，但在看了L.B的回复后，我想如何改进已被接受的答案，并使其适用于我自己的应用程序。以下是我的想法：

公共静态字符串序列化（T dataToSerialize）
{
尝试
{
var stringwriter=new System.IO.stringwriter（）；
var serializer=newxmlserializer（typeof（T））；
serializer.Serialize（stringwriter、dataToSerialize）；
返回stringwriter.ToString（）；
}
抓住
{
投掷；
}
}
公共静态T反序列化（字符串xmlText）
{
尝试
{
var stringReader=new System.IO.stringReader（xmlText）；
var serializer=newxmlserializer（typeof（T））；
返回（T）序列化程序。反序列化（stringReader）；
}
抓住
{
投掷；
}
}

这些方法现在可以放在一个静态助手类中，这意味着没有代码复制到每个需要序列化的类。

publicstaticstringserialize（objectdatatoserialize）
    public static string Serialize(object dataToSerialize)
    {
        if(dataToSerialize==null) return null;

        using (StringWriter stringwriter = new System.IO.StringWriter())
        {
            var serializer = new XmlSerializer(dataToSerialize.GetType());
            serializer.Serialize(stringwriter, dataToSerialize);
            return stringwriter.ToString();
        }
    }

    public static T Deserialize<T>(string xmlText)
    {
        if(String.IsNullOrWhiteSpace(xmlText)) return default(T);

        using (StringReader stringReader = new System.IO.StringReader(xmlText))
        {
            var serializer = new XmlSerializer(typeof(T));
            return (T)serializer.Deserialize(stringReader);
        }
    }

{
if（dataToSerialize==null）返回null；
使用（StringWriter StringWriter=new System.IO.StringWriter（））
{
var serializer=新的XmlSerializer（dataToSerialize.GetType（））；
serializer.Serialize（stringwriter、dataToSerialize）；
返回stringwriter.ToString（）；
}
}
公共静态T反序列化（字符串xmlText）
{
if（String.IsNullOrWhiteSpace（xmlText））返回默认值（T）；
使用（StringReader StringReader=new System.IO.StringReader（xmlText））
{
var serializer=newxmlserializer（typeof（T））；
返回（T）序列化程序。反序列化（stringReader）；
}
}

这是我的解决方案，对于任何列表对象，您都可以使用此代码转换为xml布局。KeyFather是您的主要标签，KeySon是您的止赎起点

public string BuildXml<T>(ICollection<T> anyObject, string keyFather, string keySon)
    {
        var settings = new XmlWriterSettings
        {
            Indent = true
        };
        PropertyDescriptorCollection props = TypeDescriptor.GetProperties(typeof(T));
        StringBuilder builder = new StringBuilder();
        using (XmlWriter writer = XmlWriter.Create(builder, settings))
        {
            writer.WriteStartDocument();
            writer.WriteStartElement(keyFather);
            foreach (var objeto in anyObject)
            {
                writer.WriteStartElement(keySon);
                foreach (PropertyDescriptor item in props)
                {
                    writer.WriteStartElement(item.DisplayName);
                    writer.WriteString(props[item.DisplayName].GetValue(objeto).ToString());
                    writer.WriteEndElement();
                }
                writer.WriteEndElement();
            }
            writer.WriteFullEndElement();
            writer.WriteEndDocument();
            writer.Flush();
            return builder.ToString();
        }
    }

publicstringbuildxml（ICollection anyObject、stringkeyfather、stringkeyson）
{
var设置=新的XmlWriterSettings
{
缩进=真
};
PropertyDescriptorCollection props=TypeDescriptor.GetProperties（typeof（T））；
StringBuilder=新的StringBuilder（）；
使用（XmlWriter=XmlWriter.Create（生成器，设置））
{
writer.WriteStartDocument（）；
writer.WriteStarteElement（关键父亲）；
foreach（anyObject中的var objeto）
{
writer.writeStart元素（keySon）；
foreach（道具中的PropertyDescriptor项）
{
writer.writeStarteElement（item.DisplayName）；
writer.WriteString（props[item.DisplayName].GetValue（objeto.ToString（））；
writer.writeedelement（）；
}
writer.writeedelement（）；
}
writer.writeFileLendElement（）；
writer.WriteEndDocument（）；
writer.Flush（）；
返回builder.ToString（）；
}
}

公共静态类XMLHelper
{
/// 
///用法：var xmlString=XMLHelper.Serialize（值）；
/// 
///碘化钾ểu dữ 锂ệU
///基托ị
///bỏ 作为申报人
///xóa编码声明
///xml字符串
公共静态字符串序列化（T值，bool-omitexmldesclaration=false，bool-omitEncodingDeclaration=true）
{
如果（值==null）
{
返回字符串。空；
}
尝试
{
var xmlWriterSettings=新的xmlWriterSettings
{
缩进=真，
OmitXmlDeclaration=OmitXmlDeclaration，//true:remove
Encoding=Encoding.UTF8，
NewLineChars=“”，//删除\r\n
};
var xmlserializer=新的xmlserializer（typeof（T））；
使用（var memoryStream=new memoryStream（））
{
使用（var xmlWriter=xmlWriter.Create（memoryStream，xmlWriterSettings））
{
serializer.Serialize（xmlWriter，值）；
//返回stringWriter.ToString（）；
}
memoryStream.Position=0；
使用（var sr=新的StreamReader（memoryStream））
{
var pureResult=sr.ReadToEnd（）；
var resultAfterOmitEncoding=ReplaceFirst（pureResult，“编码=\“utf-8\”，“”）；
if（省略编码声明）
返回resultAfterOmitEncoding；
返回pureResult；
}
 public static class XMLHelper
    {
        /// <summary>
        /// Usage: var xmlString = XMLHelper.Serialize<MyObject>(value);
        /// </summary>
        /// <typeparam name="T">Kiểu dữ liệu</typeparam>
        /// <param name="value">giá trị</param>
        /// <param name="omitXmlDeclaration">bỏ qua declare</param>
        /// <param name="removeEncodingDeclaration">xóa encode declare</param>
        /// <returns>xml string</returns>
        public static string Serialize<T>(T value, bool omitXmlDeclaration = false, bool omitEncodingDeclaration = true)
        {
            if (value == null)
            {
                return string.Empty;
            }
            try
            {
                var xmlWriterSettings = new XmlWriterSettings
                {
                    Indent = true,
                    OmitXmlDeclaration = omitXmlDeclaration, //true: remove <?xml version="1.0" encoding="utf-8"?>
                    Encoding = Encoding.UTF8,
                    NewLineChars = "", // remove \r\n
                };

                var xmlserializer = new XmlSerializer(typeof(T));

                using (var memoryStream = new MemoryStream())
                {
                    using (var xmlWriter = XmlWriter.Create(memoryStream, xmlWriterSettings))
                    {
                        xmlserializer.Serialize(xmlWriter, value);
                        //return stringWriter.ToString();
                    }

                    memoryStream.Position = 0;
                    using (var sr = new StreamReader(memoryStream))
                    {
                        var pureResult = sr.ReadToEnd();
                        var resultAfterOmitEncoding = ReplaceFirst(pureResult, " encoding=\"utf-8\"", "");
                        if (omitEncodingDeclaration)
                            return resultAfterOmitEncoding;
                        return pureResult;
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception("XMLSerialize error: ", ex);
            }
        }

        private static string ReplaceFirst(string text, string search, string replace)
        {
            int pos = text.IndexOf(search);

            if (pos < 0)
            {
                return text;
            }

            return text.Substring(0, pos) + replace + text.Substring(pos + search.Length);
        }
    }