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

我通过套接字接收XML字符串，并希望将其转换为C#对象

这些信息的形式如下：

<msg>
   <id>1</id>
   <action>stop</action>
</msg>

1.
停止

---

我是.Net新手，不确定执行此操作的最佳实践。我以前使用过JAXB for Java，不确定是否有类似的东西，或者是否会以不同的方式处理。

您需要使用

xsd.exe

工具，该工具与Windows SDK一起安装到类似的目录中：

C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin

在64位计算机上：

C:\Program Files (x86)\Microsoft SDKs\Windows\v6.0A\bin

C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\bin

在Windows 10计算机上：

C:\Program Files (x86)\Microsoft SDKs\Windows\v6.0A\bin

C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\bin

在第一次运行时，使用

xsd.exe

，并将示例XML转换为xsd文件（XML模式文件）：

这将为您提供

yourfile.xsd

，在第二步中，您可以使用

xsd.exe

再次将其转换为C类：

这将为您提供一个文件

yourfile.cs

，其中将包含一个C类，您可以使用该类来反序列化正在获取的XML文件，类似于：

XmlSerializer serializer = new XmlSerializer(typeof(msg));
msg resultingMessage = (msg)serializer.Deserialize(new XmlTextReader("yourfile.xml"));

在大多数情况下都能很好地工作

更新：XML序列化程序将采用任何流作为其输入-文件或内存流都可以：

XmlSerializer serializer = new XmlSerializer(typeof(msg));
MemoryStream memStream = new MemoryStream(Encoding.UTF8.GetBytes(inputString));
msg resultingMessage = (msg)serializer.Deserialize(memStream);

或者使用StringReader：

XmlSerializer serializer = new XmlSerializer(typeof(msg));
StringReader rdr = new StringReader(inputString);
msg resultingMessage = (msg)serializer.Deserialize(rdr);

---

如果您拥有xml消息的xsd，那么可以使用.Net xsd.exe工具生成c#类

---

然后可以使用此.Net类生成xml。

您可以使用xsd.exe在.Net中创建架构绑定类，然后使用XmlSerializer反序列化字符串：

尝试此方法将xml转换为对象。它完全是为您正在做的事情而设计的：

protected T FromXml<T>(String xml)
{
    T returnedXmlClass = default(T);

    try
    {
        using (TextReader reader = new StringReader(xml))
        {
            try
            {
                returnedXmlClass = 
                    (T)new XmlSerializer(typeof(T)).Deserialize(reader);
            }
            catch (InvalidOperationException)
            {
                // String passed is not XML, simply return defaultXmlClass
            }
        }
    }
    catch (Exception ex)
    {
    }

    return returnedXmlClass ;        
}

protectedt FromXml（字符串xml）
{
T returnedXmlClass=默认值（T）；
尝试
{
使用（TextReader=new StringReader（xml））
{
尝试
{
returnedXmlClass=
（T） 新的XmlSerializer（typeof（T））。反序列化（reader）；
}
捕获（无效操作异常）
{
//传递的字符串不是XML，只需返回defaultXmlClass即可
}
}
}
捕获（例外情况除外）
{
}
returnedXmlClass；
}

使用以下代码调用它：

YourStrongTypedEntity entity = FromXml<YourStrongTypedEntity>(YourMsgString);

YourStrongTypedEntity entity=FromXml（YourMsgString）；

除了这里的其他答案之外，您还可以自然地使用类（用于类似XML DOM的读取）或仅限快进的读取器“手动”完成此操作。

公共字符串序列化（T设置）
{
XmlSerializer serializer=新的XmlSerializer（typeof（T））；
StringWriter扩展流=新建StringWriter（）；
序列化器。序列化（扩展、设置）；
返回outStream.ToString（）；
}

您有两种可能

方法1XSD工具

---

假设您的XML文件位于此位置

C:\path\to\XML\file.XML

打开开发者命令提示符
您可以在

开始菜单>程序>Microsoft Visual Studio 2012>Visual Studio工具中找到它
或者，如果您有Windows 8，则只需在开始屏幕中键入开发者命令提示符

通过键入

cd/D“C:\path\to\XML”

通过键入

XSD file.xml从xml文件创建XSD文件

通过键入

xsd/C file.xsd

就这样！您已经从

C:\path\to\xml\file.cs中的xml文件生成了C#类

方法2-特殊粘贴

所需Visual Studio 2012+，项目目标为.Net Framework>=4.5，安装了“Windows Communication Foundation”单个组件

将XML文件的内容复制到剪贴板
向解决方案中添加新的空类文件（Shift+Alt+C）
打开该文件，然后在菜单中单击“编辑>粘贴特殊内容>将XML粘贴为类”

就这样

用法

---

此帮助器类的用法非常简单：

使用系统；
使用System.IO；
使用System.Web.Script.Serialization；//添加参考：System.Web.Extensions
使用System.Xml；
使用System.Xml.Serialization；
命名空间帮助程序
{
内部静态类解析器帮助程序
{
私有静态JavaScriptSerializer json；
私有静态JavaScriptSerializer JSON{get{return JSON？？？（JSON=new JavaScriptSerializer（））；}
公共静态流到流（此字符串@this）
{
var stream=newmemoryStream（）；
var writer=新的StreamWriter（流）；
writer.Write（@this）；
writer.Flush（）；
流位置=0；
回流；
}
公共静态T ParseXML（此字符串@this），其中T:class
{
var reader=XmlReader.Create（@this.Trim（）.ToStream（），new XmlReaderSettings（）{ConformanceLevel=ConformanceLevel.Document}）；
返回新的XmlSerializer（typeof（T））。反序列化（reader）为T；
}
公共静态T ParseJSON（此字符串@this），其中T:class
{
返回JSON.Deserialize（@this.Trim（））；
}
}
}

您现在要做的就是：

公共类JSONRoot
{
公共目录{get；set；}
}
// ...
字符串xml=File.ReadAllText（@“D:\File.xml”）；
var catalog1=xml.ParseXML（）；
字符串json=File.ReadAllText（@“D:\File.json”）；
var catalog2=json.ParseJSON（）；

只需以管理员身份运行Visual Studio 2013即可。。。 复制Xml文件的内容。。 转到Visual Studio 2013>编辑>粘贴特殊内容>将Xml粘贴为C#类

---

它将根据Xml文件内容创建c#类

以防万一，任何人都会觉得这很有用：

public static class XmlConvert
{
    public static string SerializeObject<T>(T dataObject)
    {
        if (dataObject == null)
        {
            return string.Empty;
        }
        try
        {
            using (StringWriter stringWriter = new System.IO.StringWriter())
            {
                var serializer = new XmlSerializer(typeof(T));
                serializer.Serialize(stringWriter, dataObject);
                return stringWriter.ToString();
            }
        }
        catch (Exception ex)
        {
            return string.Empty;
        }
    }

    public static T DeserializeObject<T>(string xml)
         where T : new()
    {
        if (string.IsNullOrEmpty(xml))
        {
            return new T();
        }
        try
        {
            using (var stringReader = new StringReader(xml))
            {
                var serializer = new XmlSerializer(typeof(T));
                return (T)serializer.Deserialize(stringReader);
            }
        }
        catch (Exception ex)
        {
            return new T();
        }
    }
}

公共静态类XmlConvert
{
公共静态字符串序列化对象（T dataObject）
{
if（dataObject==null）
{
返回字符串。空；
}
尝试
{
使用（StringWrite）
public static class XmlConvert
{
    public static string SerializeObject<T>(T dataObject)
    {
        if (dataObject == null)
        {
            return string.Empty;
        }
        try
        {
            using (StringWriter stringWriter = new System.IO.StringWriter())
            {
                var serializer = new XmlSerializer(typeof(T));
                serializer.Serialize(stringWriter, dataObject);
                return stringWriter.ToString();
            }
        }
        catch (Exception ex)
        {
            return string.Empty;
        }
    }

    public static T DeserializeObject<T>(string xml)
         where T : new()
    {
        if (string.IsNullOrEmpty(xml))
        {
            return new T();
        }
        try
        {
            using (var stringReader = new StringReader(xml))
            {
                var serializer = new XmlSerializer(typeof(T));
                return (T)serializer.Deserialize(stringReader);
            }
        }
        catch (Exception ex)
        {
            return new T();
        }
    }
}

MyCustomObject myObject = new MyCustomObject();
string xmlString = XmlConvert.SerializeObject(myObject)
myObject = XmlConvert.DeserializeObject<MyCustomObject>(xmlString);

[XmlRoot("msg")]
public class Message
{
    [XmlElement("id")]
    public string Id { get; set; }
    [XmlElement("action")]
    public string Action { get; set; }
}

Install-Package ExtendedXmlSerializer

var serializer = new ConfigurationContainer().Create();
var obj = new Message();
var xml = serializer.Serialize(obj);

var obj2 = serializer.Deserialize<Message>(xml);

public static T ParseXml<T>(this string value) where T : class
{
    var xmlSerializer = new XmlSerializer(typeof(T));
    using (var textReader = new StringReader(value))
    {
        return (T) xmlSerializer.Deserialize(textReader);
    }
}

string xml = System.IO.File.ReadAllText(@"C:\test\books.xml");
var book = Dandraka.XmlUtilities.XmlSlurper.ParseText(xml);

private static CustomObject getCustomObject(final String ruleStr) {
    CustomObject customObject = null;
    try {
        JAXBContext jaxbContext = JAXBContext.newInstance(CustomObject.class);
        final StringReader reader = new StringReader(ruleStr);
        Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
        customObject = (CustomObject) jaxbUnmarshaller.unmarshal(reader);
    } catch (JAXBException e) {
        LOGGER.info("getCustomObject parse error: ", e);
    }
    return customObject;
}

public class TheModel
{
    public int Id { get; set; }
    public string Action { get; set; }
}

// These are the key using statements to add.
using Newtonsoft.Json;
using System.Xml;

bool isWellFormed = false;
string xml =  = @"
<msg>
   <id>1</id>
   <action>stop</action>
</msg>
";

var xmlDocument = new XmlDocument();
xmlDocument.LoadXml(xml);
if (isWellFormed)
{
    xmlDocument.RemoveChild(xmlDocument.FirstChild); 
    /* i.e. removing the first node, which is the declaration part. 
    Also, if there are other unwanted parts in the XML, 
    write another similar code to locate the nodes 
    and remove them to only leave the desired root node 
    (and its child nodes).*/
}

var serializedXmlNode = JsonConvert.SerializeXmlNode(
            xmlDocument, 
            Newtonsoft.Json.Formatting.Indented, 
            true
            );
var theDesiredObject = JsonConvert.DeserializeObject<TheModel>(serializedXmlNode);