Interroger un XDocument pour les éléments par nom à n'importe quelle profondeur

J'ai un XDocumentobjet. Je veux interroger des éléments avec un nom particulier à n'importe quelle profondeur en utilisant LINQ. Lorsque j'utilise Descendants("element_name"), je n'obtiens que des éléments qui sont des enfants directs du niveau actuel. Ce que je recherche, c'est l'équivalent de "// nom_élément" dans XPath ... devrais-je simplement utiliser XPath, ou y a-t-il un moyen de le faire en utilisant les méthodes LINQ? Merci.

Les descendants devraient fonctionner parfaitement. Voici un exemple:

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);
        }
    }
}

Résultats:

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

Un exemple indiquant l'espace de noms:

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 );
}

Vous pouvez le faire de cette façon:

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

où xmlest unXDocument .

Sachez que la propriété Namerenvoie un objet qui a un LocalNameet un Namespace. C'est pourquoi vous devez utiliser Name.LocalNamesi vous souhaitez comparer par nom.

Les descendants feront exactement ce dont vous avez besoin, mais assurez-vous que vous avez inclus un nom d'espace de noms avec le nom de l'élément. Si vous l'omettez, vous obtiendrez probablement une liste vide.

Il y a deux façons d'accomplir cela,

1. Linq vers xml
2. XPath

Voici des exemples d'utilisation de ces approches,

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

Si vous utilisez XPath, vous devez effectuer quelques manipulations avec IEnumerable:

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

Notez que

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

résultats soit un pointeur nul, soit aucun résultat.

J'utilise une XPathSelectElementsméthode d'extension qui fonctionne de la même manière que la XmlDocument.SelectNodesméthode:

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);
            }
        }
    }
}

Suite à la réponse de @Francisco Goldenstein, j'ai écrit une méthode d'extension

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);
        }
    }
}

nous savons que ce qui précède est vrai. Jon n'a jamais tort; les souhaits de la vraie vie peuvent aller un peu plus loin

<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>

Par exemple, généralement, le problème est, comment pouvons-nous obtenir EchoToken dans le document xml ci-dessus? Ou comment brouiller l'élément avec le nom attrbute.

1- Vous pouvez les trouver en accédant avec l'espace de noms et le nom comme ci-dessous

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

2- Vous pouvez le trouver par la valeur du contenu de l'attribut, comme celui-ci

Ceci ma variante de la solution basée sur Linqet la méthode Descendants de la XDocumentclasse

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();
    }
}

Résultats:

Pour plus de détails sur la Desendantsméthode, jetez un œil ici.

(Le code et les instructions sont pour C # et peuvent devoir être légèrement modifiés pour d'autres langues)

Cet exemple fonctionne parfaitement si vous souhaitez lire à partir d'un nœud parent qui a de nombreux enfants, par exemple, regardez le code XML suivant;

<?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>

Maintenant, avec ce code ci-dessous (en gardant à l'esprit que le fichier XML est stocké dans les ressources (voir les liens à la fin de l'extrait de code pour obtenir de l'aide sur les ressources). Vous pouvez obtenir chaque adresse e-mail dans la balise "emails".

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());
}

Résultats

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

Remarque: pour l'application console et WPF ou Windows Forms, vous devez ajouter "using System.Xml.Linq;" En utilisant la directive en haut de votre projet, pour Console, vous devrez également ajouter une référence à cet espace de noms avant d'ajouter la directive Using. Aussi pour la console, il n'y aura pas de fichier de ressources par défaut sous le "dossier Propriétés", vous devez donc ajouter manuellement le fichier de ressources. Les articles MSDN ci-dessous expliquent cela en détail.

Ajout et modification de ressources

Comment: ajouter ou supprimer des ressources