将XML转换为C#对象

我需要从这些xml数据中获取OrderID：

<?xml version="1.0" encoding="utf-8"?>
<GetOrdersResponse xmlns="urn:ebay:apis:eBLBaseComponents">
  <Timestamp>2015-12-10T16:12:55.184Z</Timestamp>
  <Ack>Success</Ack>
  <Version>967</Version>
  <Build>e967_core_Bundled_5642307_R1</Build>
  <OrderArray>
    <Order>
      <OrderID>865826</OrderID>
      <OrderStatus>Active</OrderStatus>
   </Order>
  </OrderArray>
</GetOrdersResponse>

---

请给出建议。

我不希望

xDoc.Elements（“GetOrdersResponse”）

起作用，因为这是在默认名称空间中查找的，这里的所有内容都在

中“urn:ebay:api:eBLBaseComponents”

。因此，您至少需要通过

XName

告诉它：

    var xDoc = XDocument.Parse(xmlResult);
    XNamespace ns = "urn:ebay:apis:eBLBaseComponents";
    var orderElements = xDoc.Elements(ns + "GetOrdersResponse")
            .Elements(ns + "OrderArray").Elements(ns + "Order");
    foreach (XElement elem in orderElements)
    {
        var orderId = (int)elem.Element(ns + "OrderID");
    }

（注意使用

（int）

进行特定于xml的转换）

---

但是，只使用

XmlSerializer

并让它担心如何解读数据可能更容易。

对于这种问题，我总是选择使用XmlSerializer。 使用以下类别：

    using System;
    using System.Xml.Serialization;
    using System.Collections.Generic;
    namespace classes
    {
        [XmlType(Namespace = "urn:ebay:apis:eBLBaseComponents")]
   public class Order
    {
        public int OrderID { get; set; }
        public string OrderStatus { get; set; }
    }

    [XmlType(Namespace = "urn:ebay:apis:eBLBaseComponents")]
    public class OrderArray
    {
        public List<Order> Orders { get; set; }
    }

    [XmlRoot(Namespace = "urn:ebay:apis:eBLBaseComponents")]
    public class GetOrdersResponse
    {
        public string Timestamp { get; set; }
        public string Ack { get; set; }
        public string Version { get; set; }
        public string Build { get; set; }
        public OrderArray OrderArray { get; set; }
    }

    }

你可以这样做：

XDocument xdoc = XDocument.Load("YourXMLFile");
var orderId = xdoc.Descendants("OrderID").FirstOrDefault().Value;

---

您应该使用此示例代码

重要的音符

• 序列化类标记为

  [Serializable]

  attirbute
• 如果类名与xml根标记不同，则类将是 标记为

  [XmlRoot（ElementName=“xmltangame”）]

  属性
• 如果序列化类的属性类型为另一个类，则 属性标记为[

  XmlElement（“XmlTagName”）]

  属性

示例代码

型号

      [Serializable]
        [XmlRoot(ElementName = "HardwareInfo")]
        public class Hardware
        {
            [XmlElement]
            public string cpu_name { get; set; }
            [XmlElement]
            public int ram_size { get; set; }

            [XmlElement("hard_disk")]
            public List<HardDisk> hd { get; set; }                   
        }

        [Serializable]
        [XmlRoot(ElementName = "hard_disk")]
        public class HardDisk
        {
            [XmlElement]
            public string model { get; set; }
            [XmlElement]
            public string size { get; set; }
        }

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string xmlString = @"<HardwareInfo>
                                  <cpu_name> ABC Pentium xyz</cpu_name>
                                  <ram_size> 123 </ram_size>
                                  <hard_disk>
                                    <model>Toshiba XYZ</model>
                                    <size> 123 GB </size>
                                  </hard_disk>
                                  <hard_disk>
                                    <model>Logitech XYZ</model>
                                    <size> 99 GB </size>
                                  </hard_disk>
                                </HardwareInfo>";

            var result = DeSerialization<Hardware>(xmlString);
        }

        static T DeSerialization<T>(string xmlStrig) where T : class
        {
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));                        
            using (StringReader sReader = new StringReader(xmlStrig))
            {
                return (T)xmlSerializer.Deserialize(sReader);
            }
        }
    }          
}

[可序列化]
[XmlRoot（ElementName=“HardwareInfo”）]
公共级硬件
{
[XmlElement]
公共字符串cpu_name{get；set；}
[XmlElement]
公共int ram_size{get；set；}
[XmlElement（“硬盘”）]
公共列表hd{get；set；}
}
[可序列化]
[XmlRoot（ElementName=“硬盘”）]
公共类硬盘
{
[XmlElement]
公共字符串模型{get；set；}
[XmlElement]
公共字符串大小{get；set；}
}
命名空间控制台应用程序1
{
班级计划
{
静态void Main（字符串[]参数）
{
字符串xmlString=@”
ABC奔腾xyz
123
东芝XYZ
123 GB
罗技XYZ
99 GB
";
var result=反序列化（xmlString）；
}
静态T反序列化（字符串xmlStrig），其中T:class
{
XmlSerializer XmlSerializer=新的XmlSerializer（typeof（T））；
使用（StringReader sReader=新StringReader（xmlStrig））
{
返回（T）xmlSerializer.Deserialize（sReader）；
}
}
}          
}

如果要将xml数据保存在文件中，也可以使用

XmlDocument

和

XmlNodeList

获取它

        XmlDocument doc = new XmlDocument();
        doc.Load("your XML File Name with extension");
        XmlNodeList elemList = doc.GetElementsByTagName("OrderID");
        for (int i = 0; i < elemList.Count; i++)
        {
            Console.WriteLine(elemList[i].InnerText);
        }

XmlDocument doc=新的XmlDocument（）；
Load（“带扩展名的XML文件名”）；
XmlNodeList elemList=doc.GetElementsByTagName（“OrderID”）；
for（int i=0；i

“[xmltattribute（AttributeName=“xmlns”）]公共字符串xmlns{get；set；}”看起来非常错误。。。其中大多数应该是XmlType，而不是XmlRootfyi。它仍然比需要的复杂得多-

XmlSerializer

做出了很多合理的假设，比如“名称空间由孩子继承”和“东西是像成员一样命名的元素”-所以您只需要：-纯粹是FYIheh，抱歉，但我喜欢您的答案（我喜欢

XmlSerializer

），但是如果我们假设

OrderArray

实际上是0-1或多个，那么您也会丢失整个类型（

OrderArray

），而只需使用

公共列表OrderArray{get；set；}

在

GetOrdersResponse

上，这是正确的，但是在一个给定的示例中，这是不必要的。但是这应该实现，否则OrderArray将是多余的。最后，如果使用

public int OrderID{get；set；}

，正确的转换将自动进行，但这是毫无帮助的；

XmlSerializer

不关心

[Serializable]

-一点也不。问题中最主要的复杂因素是名称空间，而这个答案并没有解决这个问题；而且：它甚至不是这个问题的特定部分……这会起作用，但对于任何问题来说，

GetElementsByTagName

几乎总是一个糟糕的解决方案-极易出错等。问题中最主要的复杂因素是namespace，可以通过

XDocument

和

XmlDocument

的常规查询方法很好地处理，而不需要

GetElementsByTagName

的核心选项

      [Serializable]
        [XmlRoot(ElementName = "HardwareInfo")]
        public class Hardware
        {
            [XmlElement]
            public string cpu_name { get; set; }
            [XmlElement]
            public int ram_size { get; set; }

            [XmlElement("hard_disk")]
            public List<HardDisk> hd { get; set; }                   
        }

        [Serializable]
        [XmlRoot(ElementName = "hard_disk")]
        public class HardDisk
        {
            [XmlElement]
            public string model { get; set; }
            [XmlElement]
            public string size { get; set; }
        }

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string xmlString = @"<HardwareInfo>
                                  <cpu_name> ABC Pentium xyz</cpu_name>
                                  <ram_size> 123 </ram_size>
                                  <hard_disk>
                                    <model>Toshiba XYZ</model>
                                    <size> 123 GB </size>
                                  </hard_disk>
                                  <hard_disk>
                                    <model>Logitech XYZ</model>
                                    <size> 99 GB </size>
                                  </hard_disk>
                                </HardwareInfo>";

            var result = DeSerialization<Hardware>(xmlString);
        }

        static T DeSerialization<T>(string xmlStrig) where T : class
        {
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));                        
            using (StringReader sReader = new StringReader(xmlStrig))
            {
                return (T)xmlSerializer.Deserialize(sReader);
            }
        }
    }          
}

        XmlDocument doc = new XmlDocument();
        doc.Load("your XML File Name with extension");
        XmlNodeList elemList = doc.GetElementsByTagName("OrderID");
        for (int i = 0; i < elemList.Count; i++)
        {
            Console.WriteLine(elemList[i].InnerText);
        }