C# 如何获取作为另一个元素的后代的多个XML元素_C#_Xml_Linq

C# 如何获取作为另一个元素的后代的多个XML元素

c# xml linq

C# 如何获取作为另一个元素的后代的多个XML元素,c#,xml,linq,C#,Xml,Linq,我有一个XML文档，在另一个元素下可以有多个子元素，我想知道如何获取所有这些元素并作为对象存储？比如说- <?xml version="1.0" encoding="utf-8" ?> <export> <order> <ordernumber>100</ordernumber> <items> <item> <name>table</name&g

我有一个XML文档，在另一个元素下可以有多个子元素，我想知道如何获取所有这些元素并作为对象存储？比如说-

<?xml version="1.0" encoding="utf-8" ?>
<export>
  <order>
    <ordernumber>100</ordernumber>
    <items>
      <item>
        <name>table</name>
      </item>
      <item>
        <name>chair</name>
      </item>
    </items>
  </order>
</export>

我需要对上面的内容做些什么才能获得一个顺序中的所有项目并存储在另一个对象属性中，例如列表或类似的东西？例如

我不完全确定你想做什么。但我想可能是这样的：

var result = (from x in xdoc.Root.Elements()
              select new Order
              {
                  OrderNumber = (string)x.Element("ordernumber"),
                  Items = x.Element("items")
                           .Elements("item")
                           .Select(itemElement =>
                               new Item { Name = itemElement.Value })
                           .ToList()
              }).ToList();

var export = new Export
{
    order = new Order
    {
        orderNumber = 100,
        items = new[]
        {
            new Item {name = "table"},
            new Item {name = "chair"}
        }
    }
};

Serialize("exported_orders.xml", export);

var export = Deserialize("exported_orders.xml");

换句话说：对于给定的元素，首先找到一个

items

子元素，然后从该元素中选择其所有

item

子元素，最后从该集合中，投影到

item

对象的集合，要具体化为

列表

，并分配给

Order.Items

属性

（注意：您将命名类型

Order

与表示

项

XML元素的匿名类型混合在一起；我修复了代码，使其在任何地方都使用命名类型，但如果您愿意，当然可以在任何地方使用匿名）。

我不完全确定您想做什么。但我想可能是这样的：

var result = (from x in xdoc.Root.Elements()
              select new Order
              {
                  OrderNumber = (string)x.Element("ordernumber"),
                  Items = x.Element("items")
                           .Elements("item")
                           .Select(itemElement =>
                               new Item { Name = itemElement.Value })
                           .ToList()
              }).ToList();

var export = new Export
{
    order = new Order
    {
        orderNumber = 100,
        items = new[]
        {
            new Item {name = "table"},
            new Item {name = "chair"}
        }
    }
};

Serialize("exported_orders.xml", export);

var export = Deserialize("exported_orders.xml");

换句话说：对于给定的元素，首先找到一个

items

子元素，然后从该元素中选择其所有

item

子元素，最后从该集合中，投影到

item

对象的集合，要具体化为

列表

，并分配给

Order.Items

属性

（注意：您将命名类型

Order

与表示

项

XML元素的匿名类型混合在一起；我修复了代码，使其在任何地方都使用命名类型，但如果愿意，您当然可以在任何地方使用匿名）。

我认为您需要：-

List<Order> orders = xdoc.Descendants("order")
                    .Select(x => new Order
                    {
                      OrderNumber = (string)x.Element("ordernumber"),
                      Items = x.Descendants("item")
                               .Select(i => new Item
                               {
                                  Name = (string)i.Element("name") }).ToList()
                               }).ToList();

List orders=xdoc.substands（“订单”）
.选择（x=>新订单
{
OrderNumber=（字符串）x.Element（“OrderNumber”），
项目=x.1（“项目”）
.选择（i=>新项目
{
Name=（string）i.Element（“Name”）}.ToList（）
}).ToList（）；

我使用的类型：-

public class Order
{
    public string OrderNumber { get; set; }
    public List<Item> Items { get; set; }
}

public class Item
{
    public string Name { get; set; }
}

公共类秩序
{
公共字符串OrderNumber{get；set；}
公共列表项{get；set；}
}
公共类项目
{
公共字符串名称{get；set；}
}

我想你需要这个：-

List<Order> orders = xdoc.Descendants("order")
                    .Select(x => new Order
                    {
                      OrderNumber = (string)x.Element("ordernumber"),
                      Items = x.Descendants("item")
                               .Select(i => new Item
                               {
                                  Name = (string)i.Element("name") }).ToList()
                               }).ToList();

List orders=xdoc.substands（“订单”）
.选择（x=>新订单
{
OrderNumber=（字符串）x.Element（“OrderNumber”），
项目=x.1（“项目”）
.选择（i=>新项目
{
Name=（string）i.Element（“Name”）}.ToList（）
}).ToList（）；

我使用的类型：-

public class Order
{
    public string OrderNumber { get; set; }
    public List<Item> Items { get; set; }
}

public class Item
{
    public string Name { get; set; }
}

公共类秩序
{
公共字符串OrderNumber{get；set；}
公共列表项{get；set；}
}
公共类项目
{
公共字符串名称{get；set；}
}

基于名为export的根元素，我认为您可能正在尝试序列化/反序列化程序中的对象：

[XmlRoot("export")]
public class Export
{
    [XmlElement("order")]
    public Order order {get; set;}
}

public class Order
{
    [XmlElement("ordernumber")]
    public int orderNumber { get; set; }
    [XmlArray("items"), XmlArrayItem("item")]
    public Item[] items { get; set; }
}

public class Item
{
    public string name { get; set; }
}

static void Serialize(string file, Export export)
{
    var serializer = new XmlSerializer(typeof(Export));
    using (var stream = File.Create(file))
        serializer.Serialize(stream, export);
}

static Export Deserialize(string file)
{
    var serializer = new XmlSerializer(typeof(Export));
    using (var stream = File.OpenRead(file))
        return (Export) serializer.Deserialize(stream);
}

你可以这样称呼它：

var result = (from x in xdoc.Root.Elements()
              select new Order
              {
                  OrderNumber = (string)x.Element("ordernumber"),
                  Items = x.Element("items")
                           .Elements("item")
                           .Select(itemElement =>
                               new Item { Name = itemElement.Value })
                           .ToList()
              }).ToList();

var export = new Export
{
    order = new Order
    {
        orderNumber = 100,
        items = new[]
        {
            new Item {name = "table"},
            new Item {name = "chair"}
        }
    }
};

Serialize("exported_orders.xml", export);

var export = Deserialize("exported_orders.xml");

就像这样：

var result = (from x in xdoc.Root.Elements()
              select new Order
              {
                  OrderNumber = (string)x.Element("ordernumber"),
                  Items = x.Element("items")
                           .Elements("item")
                           .Select(itemElement =>
                               new Item { Name = itemElement.Value })
                           .ToList()
              }).ToList();

var export = new Export
{
    order = new Order
    {
        orderNumber = 100,
        items = new[]
        {
            new Item {name = "table"},
            new Item {name = "chair"}
        }
    }
};

Serialize("exported_orders.xml", export);

var export = Deserialize("exported_orders.xml");

基于名为export的根元素，我认为您可能正在尝试序列化/反序列化程序中的对象：

[XmlRoot("export")]
public class Export
{
    [XmlElement("order")]
    public Order order {get; set;}
}

public class Order
{
    [XmlElement("ordernumber")]
    public int orderNumber { get; set; }
    [XmlArray("items"), XmlArrayItem("item")]
    public Item[] items { get; set; }
}

public class Item
{
    public string name { get; set; }
}

static void Serialize(string file, Export export)
{
    var serializer = new XmlSerializer(typeof(Export));
    using (var stream = File.Create(file))
        serializer.Serialize(stream, export);
}

static Export Deserialize(string file)
{
    var serializer = new XmlSerializer(typeof(Export));
    using (var stream = File.OpenRead(file))
        return (Export) serializer.Deserialize(stream);
}

你可以这样称呼它：

var result = (from x in xdoc.Root.Elements()
              select new Order
              {
                  OrderNumber = (string)x.Element("ordernumber"),
                  Items = x.Element("items")
                           .Elements("item")
                           .Select(itemElement =>
                               new Item { Name = itemElement.Value })
                           .ToList()
              }).ToList();

var export = new Export
{
    order = new Order
    {
        orderNumber = 100,
        items = new[]
        {
            new Item {name = "table"},
            new Item {name = "chair"}
        }
    }
};

Serialize("exported_orders.xml", export);

var export = Deserialize("exported_orders.xml");

就像这样：

var result = (from x in xdoc.Root.Elements()
              select new Order
              {
                  OrderNumber = (string)x.Element("ordernumber"),
                  Items = x.Element("items")
                           .Elements("item")
                           .Select(itemElement =>
                               new Item { Name = itemElement.Value })
                           .ToList()
              }).ToList();

var export = new Export
{
    order = new Order
    {
        orderNumber = 100,
        items = new[]
        {
            new Item {name = "table"},
            new Item {name = "chair"}
        }
    }
};

Serialize("exported_orders.xml", export);

var export = Deserialize("exported_orders.xml");

如果要将XML转换为对象，通常只需将类型声明为

[Serializable]

，并将XML反序列化为该类型（或以某种方式从中复制到实际类型的代理类型），就更简单了。至于直接处理XML，您是否研究过or方法？如果您想将XML转换为对象，通常只需将类型声明为

[Serializable]

并将XML反序列化为类型（或以某种方式从中复制到实际类型的代理类型），就更简单了。至于直接处理XML，您看过or方法吗？这就成功了！我使用了您的代码的一个变体，因为我确实有一个Item对象，并且它有多个属性，所以我使用了“Name=itemlelement.Element（“Name”）.Value”等等，这样就成功了！我使用了您代码的一个变体，因为我确实有一个Item对象，并且它有多个属性，所以我使用了“Name=itemElement.Element（“Name”）.Value”等等。这个答案也非常有效，但是Peter先发布了，所以我接受他的答案是公平的。谢谢你的回答+1这个答案也很完美，但彼得先发了帖子，所以我接受他的答案是公平的。谢谢你的回答+1.