Lecture spécifique des éléments XML à partir du fichier XML

J'ai le fichier XML suivant

<lexicon>
<word>
  <base>a</base>
  <category>determiner</category>
  <id>E0006419</id>
</word>
<word>
  <base>abandon</base>
  <category>verb</category>
  <id>E0006429</id>
  <ditransitive/>
  <transitive/>
</word>
<word>
  <base>abbey</base>
  <category>noun</category>
  <id>E0203496</id>
</word>
<word>
  <base>ability</base>
  <category>noun</category>
  <id>E0006490</id>
</word>
<word>
  <base>able</base>
  <category>adjective</category>
  <id>E0006510</id>
  <predicative/>
  <qualitative/>
</word>
<word>
  <base>abnormal</base>
  <category>adjective</category>
  <id>E0006517</id>
  <predicative/>
  <qualitative/>
</word>
<word>
  <base>abolish</base>
  <category>verb</category>
  <id>E0006524</id>
  <transitive/>
</word>
</lexicon>

J'ai besoin de lire ce fichier avec une application en C#, et si seulement le category est verb je veux imprimer l'ensemble de son élément word.
Comment puis-je le faire?

ont u essayé à l'aide de Linq to XML ?
Pouvez-vous me montrer comment faire?
vous êtes censé faire votre propre recherche en premier, puis viennent quand vous êtes en difficulté. Une recherche sur google ou une recherche de ce qui aurait montré comment parser un fichier XML.

OriginalL'auteur Ruba | 2013-01-01

c#xml

Vous pouvez utiliser linq to xml.

    var xmlStr = File.ReadAllText("fileName.xml");


    var str = XElement.Parse(xmlStr);

    var result = str.Elements("word").
Where(x => x.Element("category").Value.Equals("verb")).ToList();

    Console.WriteLine(result);

OriginalL'auteur scartag

Vous pouvez utiliser un XPath, trop. Un peu vieux jeu, mais toujours efficace:

using System.Xml;

...

XmlDocument xmlDocument;

xmlDocument = new XmlDocument();
xmlDocument.LoadXml(xml);

foreach (XmlElement xmlElement in 
    xmlDocument.DocumentElement.SelectNodes("word[category='verb']"))
{
    Console.Out.WriteLine(xmlElement.OuterXml);
}

Je suis en désaccord que XPath est à l'ancienne, j'aime beaucoup de XPath
Je veux dire.. vous pouvez comme vous voulez, mais par rapport à linq to xml, c'est à l'ancienne.

OriginalL'auteur akton

2
```
XDocument xdoc = XDocument.Load(path_to_xml);
var word = xdoc.Elements("word")
               .SingleOrDefault(w => (string)w.Element("category") == "verb");
```
Cette requête sera de retour tout le mot XElement. Si il n'y a plus d'un élément verbal de la catégorie verb, que vous obtiendrez un InvalidOperationException. Si il n'y a pas d'éléments avec la catégorie verb, le résultat sera null.

OriginalL'auteur Sergey Berezovskiy

C'est comment j'allais le faire (le code ci-dessous a été testée, la totalité du code source fourni ci-dessous), à commencer par la création d'une classe avec des propriétés communes

    class Word
    {
        public string Base { get; set; }
        public string Category { get; set; }
        public string Id { get; set; }
    }

charge à l'aide de XDocument avec INPUT_DATA à des fins de démonstration et de trouver le nom de l'élément avec lexique . . .

    XDocument doc = XDocument.Parse(INPUT_DATA);
    XElement lex = doc.Element("lexicon");

assurez-vous que la valeur et de l'utilisation de linq pour extraire le mot éléments . . .

    Word[] catWords = null;
    if (lex != null)
    {
        IEnumerable<XElement> words = lex.Elements("word");
        catWords = (from itm in words
                    where itm.Element("category") != null
                        && itm.Element("category").Value == "verb"
                        && itm.Element("id") != null
                        && itm.Element("base") != null
                    select new Word() 
                    {
                        Base = itm.Element("base").Value,
                        Category = itm.Element("category").Value,
                        Id = itm.Element("id").Value,
                    }).ToArray<Word>();
    }

La where instruction vérifie si la catégorie de l'élément existe et que la catégorie de la valeur n'est pas null et puis vérifier à nouveau que c'est un verbe. Vérifiez ensuite que les autres nœuds existe aussi . . .

La requête linq sera de retour un IEnumerable< Typename > objet, de sorte que nous pouvons appeler ToArray< Typename >() pour lancer l'ensemble de la collection dans le type que nous voulons.

Ensuite l'imprimer pour l'obtenir . . .

[Found]
 Id: E0006429
 Base: abandon
 Category: verb

[Found]
 Id: E0006524
 Base: abolish
 Category: verb

Source Complet:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;
namespace test
{
class Program
{
class Word
{
public string Base { get; set; }
public string Category { get; set; }
public string Id { get; set; }
}
static void Main(string[] args)
{
XDocument doc = XDocument.Parse(INPUT_DATA);
XElement lex = doc.Element("lexicon");
Word[] catWords = null;
if (lex != null)
{
IEnumerable<XElement> words = lex.Elements("word");
catWords = (from itm in words
where itm.Element("category") != null
&& itm.Element("category").Value == "verb"
&& itm.Element("id") != null
&& itm.Element("base") != null
select new Word() 
{
Base = itm.Element("base").Value,
Category = itm.Element("category").Value,
Id = itm.Element("id").Value,
}).ToArray<Word>();
}
//print it
if (catWords != null)
{
Console.WriteLine("Words with <category> and value verb:\n");
foreach (Word itm in catWords)
Console.WriteLine("[Found]\n Id: {0}\n Base: {1}\n Category: {2}\n", 
itm.Id, itm.Base, itm.Category);
}
}
const string INPUT_DATA =
@"<?xml version=""1.0""?>
<lexicon>
<word>
<base>a</base>
<category>determiner</category>
<id>E0006419</id>
</word>
<word>
<base>abandon</base>
<category>verb</category>
<id>E0006429</id>
<ditransitive/>
<transitive/>
</word>
<word>
<base>abbey</base>
<category>noun</category>
<id>E0203496</id>
</word>
<word>
<base>ability</base>
<category>noun</category>
<id>E0006490</id>
</word>
<word>
<base>able</base>
<category>adjective</category>
<id>E0006510</id>
<predicative/>
<qualitative/>
</word>
<word>
<base>abnormal</base>
<category>adjective</category>
<id>E0006517</id>
<predicative/>
<qualitative/>
</word>
<word>
<base>abolish</base>
<category>verb</category>
<id>E0006524</id>
<transitive/>
</word>
</lexicon>";
}
}

La bonne façon de le faire.

OriginalL'auteur rbtLong

Alternativement, vous pouvez utiliser XPath requête via XPathSelectElements méthode:

var document = XDocument.Parse(yourXmlAsString);
var words = document.XPathSelectElements("//word[./category[text() = 'verb']]");

OriginalL'auteur k.m

Vous devez vous connecter pour publier un commentaire.