Lire XML en C#
Il existe plusieurs façons de lire un fichier XML en C# et chaque méthode a ses avantages et ses inconvénients, et le choix dépend des exigences du projet. Voici quelques façons de lire un fichier XML en C# :
- Utilisation de XmlDocument
- Utilisation de XDocument
- Utilisation de XmlReader
- Utilisation de XML vers LINQ
- Utilisation de XPath
Voici le contenu du fichier XML que j'ai créé et qui sera utilisé pour la démonstration dans les méthodes à venir :
< ?xml version = '1.0' codage = 'utf-8' ? >
< employés >
< employé >
< identifiant > 1 identifiant >
< nom > Sam bosh nom >
< département > Commercialisation département >
< salaire > 50000 salaire >
employé >
< employé >
< identifiant > 2 identifiant >
< nom > Jane Doe nom >
< département > Finance département >
< salaire > 60000 salaire >
employé >
< employé >
< identifiant > 3 identifiant >
< nom > James nom >
< département > Ressources humaines département >
< salaire > 70000 salaire >
employé >
employés >
1 : Utiliser XmlDocument
Pour lire un fichier XML en C#, vous pouvez utiliser la classe XmlDocument ou la classe XDocument, qui font toutes deux partie de l'espace de noms System.Xml. La classe XmlDocument fournit une approche DOM (Document Object Model) pour lire XML, tandis que la classe XDocument fournit une approche LINQ (Language-Integrated Query). Voici un exemple utilisant la classe XmlDocument pour lire un fichier XML :
utiliser le système ;
en utilisant System.Xml ;
Programme de classe
{
vide statique principal ( chaîne [ ] arguments )
{
XmlDocument doc = nouveau XmlDocument ( ) ;
doc.Load ( 'employés.xml' ) ;
Nœuds XmlNodeList = doc.DocumentElement.SelectNodes ( '/employés/employé' ) ;
pour chaque ( Nœud XmlNodeXmlNode node dans nœuds )
{
chaîne identifiant = node.SelectSingleNode ( 'identifiant' ) .InnerText ;
nom de chaîne = node.SelectSingleNode ( 'nom' ) .InnerText ;
chaîne département = node.SelectSingleNode ( 'département' ) .InnerText ;
salaire de chaîne = node.SelectSingleNode ( 'salaire' ) .InnerText ;
Console.WriteLineConsole.WriteLine ( 'ID : {0}, Nom : {1}, Département : {2}, Salaire : {3}' , identifiant , nom, service, salaire ) ;
}
}
}
Ce code utilise la classe XmlDocument pour charger le fichier XML et la méthode SelectNodes pour récupérer une liste de nœuds d'employés. Ensuite, pour chaque nœud d'employé, il utilise la méthode SelectSingleNode pour récupérer les valeurs des nœuds enfants d'id, de nom, de service et de salaire et les affiche à l'aide de Console.WriteLine :
2 : Utiliser XDocument
Alternativement, vous pouvez également utiliser la classe XDocument pour lire un fichier XML en utilisant une approche LINQ, et ci-dessous est le code qui illustre comment le faire :
utiliser le système ;Programme de classe
{
vide statique principal ( chaîne [ ] arguments )
{
XDocument doc = XDocument.Load ( 'employés.xml' ) ;
pour chaque ( Élément XElement dans doc.Descendants ( 'employé' ) )
{
entier identifiant = int.Parser ( élément.Élément ( 'identifiant' ) .Valeur ) ;
nom de chaîne = élément.Élément ( 'nom' ) .Valeur;
chaîne département = élément.Élément ( 'département' ) .Valeur;
int salaire = int.Parse ( élément.Élément ( 'salaire' ) .Valeur ) ;
Console.WriteLineConsole.WriteLine ( $ 'Identifiant : {id}, Nom : {name}, Département : {department}, Salaire : {salary}' ) ;
}
}
}
Le fichier XML est chargé dans un objet XDocument à l'aide de la méthode XDocument.Load. Les éléments « employé » du fichier XML sont alors tous récupérés grâce à la technique des Descendants. Pour chaque élément, ses éléments enfants sont accessibles à l'aide de la méthode Element et leurs valeurs sont extraites à l'aide de la propriété Value. Enfin, les données extraites sont imprimées sur la console.
Notez que XDocument appartient à l'espace de noms System.Xml.Linq, vous devez donc inclure l'instruction using suivante en haut de votre fichier C#
3 : Utiliser XmlReader
XmlReader est un moyen rapide et efficace de lire un fichier XML en C#. Il lit le fichier de manière séquentielle, ce qui signifie qu'il ne charge qu'un nœud à la fois, ce qui le rend idéal pour travailler avec de gros fichiers XML qui seraient autrement difficiles à gérer en mémoire.
utiliser le système ;en utilisant System.Xml ;
Programme de classe
{
vide statique principal ( chaîne [ ] arguments )
{
en utilisant ( Lecteur XmlReader = XmlReader.Create ( 'employés.xml' ) )
{
alors que ( lecteur.Lire ( ) )
{
si ( lecteur.NodeType == XmlNodeType.Element && lecteur.Name == 'employé' )
{
Console.WriteLineConsole.WriteLine ( 'IDENTIFIANT: ' + lecteur.GetAttribute ( 'identifiant' ) ) ;
lecteur.ReadToDescendant ( 'nom' ) ;
Console.WriteLineConsole.WriteLine ( 'Nom: ' + lecteur.ReadElementContentAsString ( ) ) ;
lecteur.ReadToNextSibling ( 'département' ) ;
Console.WriteLineConsole.WriteLine ( 'Département: ' + lecteur.ReadElementContentAsString ( ) ) ;
lecteur.ReadToNextSibling ( 'salaire' ) ;
Console.WriteLineConsole.WriteLine ( 'Salaire: ' + lecteur.ReadElementContentAsString ( ) ) ;
}
}
}
}
}
Dans cet exemple, nous utilisons XmlReader.Create une méthode pour créer une instance de XmlReader et transmettre le chemin du fichier XML en tant que paramètre. Nous utilisons ensuite une boucle while pour lire le fichier XML nœud par nœud à l'aide de la méthode Read de XmlReader.
Dans la boucle, nous vérifions d'abord si le nœud actuel est un élément employé à l'aide des propriétés NodeType et Name de XmlReader. Si tel est le cas, nous utilisons la méthode GetAttribute pour récupérer la valeur de l'attribut id.
Ensuite, nous utilisons la méthode ReadToDescendant pour déplacer le lecteur vers l'élément name à l'intérieur de l'élément employee. La valeur de l'élément de nom est ensuite obtenue à l'aide de la fonction ReadElementContentAsString.
De même, nous utilisons la méthode ReadToNextSibling pour déplacer le lecteur vers l'élément frère suivant et obtenir la valeur des éléments département et salaire.
Enfin, nous utilisons using block pour nous assurer que l'objet XmlReader est correctement éliminé une fois la lecture du fichier XML terminée :
4 : XML vers LINQ
La lecture d'un fichier XML à l'aide de LINQ to XML en C# est un moyen puissant d'accéder aux données XML et de les manipuler. LINQ to XML est un composant de la technologie LINQ qui fournit une API simple et efficace pour travailler avec des données XML.
utiliser le système ;en utilisant System.Linq ;
en utilisant System.Xml.Linq ;
Programme de classe
{
vide statique principal ( chaîne [ ] arguments )
{
XDocument doc = XDocument.Load ( 'employés.xml' ) ;
var employés = de e dans doc.Descendants ( 'employé' )
sélectionner nouveau
{
Id = e.Element ( 'identifiant' ) .Valeur,
Nom = e.Element ( 'nom' ) .Valeur,
Département = e.Element ( 'département' ) .Valeur,
Salaire = e.Element ( 'salaire' ) .Valeur
} ;
pour chaque ( employé var dans employés )
{
Console.WriteLineConsole.WriteLine ( $ 'Identifiant : {employee.Id}, Nom : {employee.Name}, Département : {employee.Department}, Salaire : {employee.Salary}' ) ;
}
}
}
Dans ce code, nous chargeons d'abord le fichier XML à l'aide de la méthode XDocument.Load(). Ensuite, nous utilisons LINQ to XML pour interroger les données XML et sélectionner les éléments d'identifiant, de nom, de service et de salaire pour chaque élément d'employé. Nous stockons ces données dans un type anonyme, puis parcourons les résultats pour imprimer les informations sur les employés dans la console.
5 : Utiliser XPath
XPath est un langage de requête utilisé pour naviguer dans un document XML afin de localiser des éléments, des attributs et des nœuds spécifiques. C'est un outil efficace pour la recherche et le filtrage d'informations dans un document XML. En C #, nous pouvons utiliser le langage XPath pour lire et extraire des données à partir de fichiers XML.
utiliser le système ;en utilisant System.Xml.XPath ;
en utilisant System.Xml ;
Programme de classe
{
vide statique principal ( chaîne [ ] arguments )
{
XmlDocument doc = nouveau XmlDocument ( ) ;
doc.Load ( 'employés.xml' ) ;
// Créer un XPathNavigator à partir du document
XPathNavigator nav = doc.CreateNavigator ( ) ;
// Compiler l'expression XPath
XPathExpressionXPathExpression expr = nav.Compile ( '/employés/employé/nom' ) ;
// Évaluer l'expression et parcourir les résultats
Itérateur XPathNodeIterator = nav.Select ( expr ) ;
alors que ( iterator.MoveNext ( ) )
{
Console.WriteLineConsole.WriteLine ( iterator.Current.Value ) ;
}
}
}
Ce code charge le fichier « employees.xml » à l'aide d'un XmlDocument, crée un XPathNavigator à partir du document et compile une expression XPath pour sélectionner tous les éléments
Note: l'utilisation de XPath peut être un moyen puissant et flexible de sélectionner des éléments et des attributs à partir d'un document XML, mais cela peut aussi être plus complexe que certaines des autres méthodes dont nous avons parlé.
Conclusion
L'utilisation de la classe XmlDocument fournit des fonctionnalités de manipulation DOM complètes, mais elle peut être plus lente et plus gourmande en mémoire que les autres méthodes. La classe XmlReader est une bonne option pour lire des fichiers XML volumineux, car elle fournit une approche basée sur les flux rapide, en avant uniquement et non mise en cache. La classe XDocument fournit une syntaxe plus simple et plus concise, mais elle peut ne pas être aussi performante que XmlReader. De plus, les méthodes LINQ to XML et XPath offrent de puissantes capacités d'interrogation pour extraire des données spécifiques d'un fichier XML.