Fragen Sie ein XDocument nach Elementen in einer beliebigen Tiefe nach Namen ab

Ich habe ein XDocumentObjekt. Ich möchte mit LINQ in jeder Tiefe nach Elementen mit einem bestimmten Namen suchen. Wenn ich benutze Descendants("element_name"), bekomme ich nur Elemente, die direkte Kinder der aktuellen Ebene sind. Was ich suche, ist das Äquivalent von "// element_name" in XPath ... sollte ich nur verwenden XPath, oder gibt es eine Möglichkeit, dies mit LINQ-Methoden zu tun? Vielen Dank.

Nachkommen sollten absolut gut funktionieren. Hier ist ein Beispiel:

using System;
using System.Xml.Linq;

class Test
{
    static void Main()
    {
        string xml = @"
<root>
  <child id='1'/>
  <child id='2'>
    <grandchild id='3' />
    <grandchild id='4' />
  </child>
</root>";
        XDocument doc = XDocument.Parse(xml);

        foreach (XElement element in doc.Descendants("grandchild"))
        {
            Console.WriteLine(element);
        }
    }
}

Ergebnisse:

<grandchild id="3" />
<grandchild id="4" />

Ein Beispiel für den Namespace:

String TheDocumentContent =
@"
<TheNamespace:root xmlns:TheNamespace = 'http://www.w3.org/2001/XMLSchema' >
   <TheNamespace:GrandParent>
      <TheNamespace:Parent>
         <TheNamespace:Child theName = 'Fred'  />
         <TheNamespace:Child theName = 'Gabi'  />
         <TheNamespace:Child theName = 'George'/>
         <TheNamespace:Child theName = 'Grace' />
         <TheNamespace:Child theName = 'Sam'   />
      </TheNamespace:Parent>
   </TheNamespace:GrandParent>
</TheNamespace:root>
";

XDocument TheDocument = XDocument.Parse( TheDocumentContent );

//Example 1:
var TheElements1 =
from
    AnyElement
in
    TheDocument.Descendants( "{http://www.w3.org/2001/XMLSchema}Child" )
select
    AnyElement;

ResultsTxt.AppendText( TheElements1.Count().ToString() );

//Example 2:
var TheElements2 =
from
    AnyElement
in
    TheDocument.Descendants( "{http://www.w3.org/2001/XMLSchema}Child" )
where
    AnyElement.Attribute( "theName" ).Value.StartsWith( "G" )
select
    AnyElement;

foreach ( XElement CurrentElement in TheElements2 )
{
    ResultsTxt.AppendText( "\r\n" + CurrentElement.Attribute( "theName" ).Value );
}

Sie können es so machen:

xml.Descendants().Where(p => p.Name.LocalName == "Name of the node to find")

wo xmlist einXDocument .

Beachten Sie, dass die Eigenschaft Nameein Objekt mit a LocalNameund a zurückgibt Namespace. Deshalb müssen Sie verwenden, Name.LocalNamewenn Sie nach Namen vergleichen möchten.

Nachkommen tun genau das, was Sie brauchen, aber stellen Sie sicher, dass Sie einen Namespace-Namen zusammen mit dem Namen des Elements angegeben haben. Wenn Sie es weglassen, erhalten Sie wahrscheinlich eine leere Liste.

Es gibt zwei Möglichkeiten, dies zu erreichen:

1. Linq-to-xml
2. XPath

Das Folgende sind Beispiele für die Verwendung dieser Ansätze:

List<XElement> result = doc.Root.Element("emails").Elements("emailAddress").ToList();

Wenn Sie XPath verwenden, müssen Sie einige Manipulationen mit IEnumerable durchführen:

IEnumerable<XElement> mails = ((IEnumerable)doc.XPathEvaluate("/emails/emailAddress")).Cast<XElement>();

Beachten Sie, dass

var res = doc.XPathEvaluate("/emails/emailAddress");

ergibt entweder einen Nullzeiger oder keine Ergebnisse.

Ich verwende eine XPathSelectElementsErweiterungsmethode, die genauso funktioniert wie die XmlDocument.SelectNodesMethode:

using System;
using System.Xml.Linq;
using System.Xml.XPath; // for XPathSelectElements

namespace testconsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            XDocument xdoc = XDocument.Parse(
                @"<root>
                    <child>
                        <name>john</name>
                    </child>
                    <child>
                        <name>fred</name>
                    </child>
                    <child>
                        <name>mark</name>
                    </child>
                 </root>");

            foreach (var childElem in xdoc.XPathSelectElements("//child"))
            {
                string childName = childElem.Element("name").Value;
                Console.WriteLine(childName);
            }
        }
    }
}

Nach der Antwort von @Francisco Goldenstein habe ich eine Erweiterungsmethode geschrieben

using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace Mediatel.Framework
{
    public static class XDocumentHelper
    {
        public static IEnumerable<XElement> DescendantElements(this XDocument xDocument, string nodeName)
        {
            return xDocument.Descendants().Where(p => p.Name.LocalName == nodeName);
        }
    }
}

Wir wissen, dass das oben Genannte wahr ist. Jon liegt niemals falsch; reale Wünsche können ein wenig weiter gehen

<ota:OTA_AirAvailRQ
    xmlns:ota="http://www.opentravel.org/OTA/2003/05" EchoToken="740" Target=" Test" TimeStamp="2012-07-19T14:42:55.198Z" Version="1.1">
    <ota:OriginDestinationInformation>
        <ota:DepartureDateTime>2012-07-20T00:00:00Z</ota:DepartureDateTime>
    </ota:OriginDestinationInformation>
</ota:OTA_AirAvailRQ>

Beispiel: Normalerweise besteht das Problem darin, wie wir EchoToken im obigen XML-Dokument erhalten können. Oder wie man das Element mit dem Namen attrbute verwischt.

1- Sie können sie finden, indem Sie mit dem Namespace und dem Namen wie unten darauf zugreifen

doc.Descendants().Where(p => p.Name.LocalName == "OTA_AirAvailRQ").Attributes("EchoToken").FirstOrDefault().Value

2- Sie finden es am Attributinhaltswert wie diesem

Dies ist meine Variante der Lösung basierend auf Linqund Descendants Methode der XDocumentKlasse

using System;
using System.Linq;
using System.Xml.Linq;

class Test
{
    static void Main()
    {
        XDocument xml = XDocument.Parse(@"
        <root>
          <child id='1'/>
          <child id='2'>
            <subChild id='3'>
                <extChild id='5' />
                <extChild id='6' />
            </subChild>
            <subChild id='4'>
                <extChild id='7' />
            </subChild>
          </child>
        </root>");

        xml.Descendants().Where(p => p.Name.LocalName == "extChild")
                         .ToList()
                         .ForEach(e => Console.WriteLine(e));

        Console.ReadLine();
    }
}

Ergebnisse:

Weitere Details zur DesendantsMethode finden Sie hier.

(Code und Anweisungen gelten für C # und müssen möglicherweise für andere Sprachen geringfügig geändert werden.)

Dieses Beispiel funktioniert perfekt, wenn Sie von einem übergeordneten Knoten mit vielen untergeordneten Knoten lesen möchten. Sehen Sie sich beispielsweise das folgende XML an.

<?xml version="1.0" encoding="UTF-8"?> 
<emails>
    <emailAddress>jdoe@set.ca</emailAddress>
    <emailAddress>jsmith@hit.ca</emailAddress>
    <emailAddress>rgreen@set_ig.ca</emailAddress> 
</emails>

Mit diesem Code unten (unter Berücksichtigung der Tatsache, dass die XML-Datei in Ressourcen gespeichert ist (Hilfe zu Ressourcen finden Sie unter den Links am Ende des Snippets)) können Sie jede E-Mail-Adresse innerhalb des Tags "E-Mails" abrufen.

XDocument doc = XDocument.Parse(Properties.Resources.EmailAddresses);

var emailAddresses = (from emails in doc.Descendants("emailAddress")
                      select emails.Value);

foreach (var email in emailAddresses)
{
    //Comment out if using WPF or Windows Form project
    Console.WriteLine(email.ToString());

   //Remove comment if using WPF or Windows Form project
   //MessageBox.Show(email.ToString());
}

Ergebnisse

1. jdoe@set.ca
2. jsmith@hit.ca
3. rgreen@set_ig.ca

Hinweis: Für Konsolenanwendungen und WPF- oder Windows Forms müssen Sie "using System.Xml.Linq;" hinzufügen. Wenn Sie die Direktive oben in Ihrem Projekt verwenden, müssen Sie für Console auch einen Verweis auf diesen Namespace hinzufügen, bevor Sie die Direktive Using hinzufügen. Auch für die Konsole befindet sich standardmäßig keine Ressourcendatei unter dem Ordner "Eigenschaften", sodass Sie die Ressourcendatei manuell hinzufügen müssen. In den folgenden MSDN-Artikeln wird dies ausführlich erläutert.

Hinzufügen und Bearbeiten von Ressourcen

Gewusst wie: Hinzufügen oder Entfernen von Ressourcen