Comment analyser les fichiers XML? [fermé]

Existe-t-il une méthode simple d'analyse des fichiers XML en C #? Si oui, quoi?

J'utiliserais LINQ to XML si vous êtes en .NET 3.5 ou supérieur.

C'est très simple. Je sais que ce sont des méthodes standard, mais vous pouvez créer votre propre bibliothèque pour mieux gérer cela.

Voici quelques exemples:

XmlDocument xmlDoc= new XmlDocument(); // Create an XML document object
xmlDoc.Load("yourXMLFile.xml"); // Load the XML document from the specified file

// Get elements
XmlNodeList girlAddress = xmlDoc.GetElementsByTagName("gAddress");
XmlNodeList girlAge = xmlDoc.GetElementsByTagName("gAge"); 
XmlNodeList girlCellPhoneNumber = xmlDoc.GetElementsByTagName("gPhone");

// Display the results
Console.WriteLine("Address: " + girlAddress[0].InnerText);
Console.WriteLine("Age: " + girlAge[0].InnerText);
Console.WriteLine("Phone Number: " + girlCellPhoneNumber[0].InnerText);

En outre, il existe d' autres méthodes avec lesquelles travailler. Par exemple, ici . Et je pense qu'il n'y a pas de meilleure méthode pour le faire; vous devez toujours le choisir vous-même, ce qui vous convient le mieux.

Utilisez un bon schéma XSD pour créer un ensemble de classes avec xsd.exe et utilisez un XmlSerializerpour créer une arborescence d'objets à partir de votre XML et vice versa. Si vous avez peu de restrictions sur votre modèle, vous pouvez même essayer de créer un mappage direct entre vos classes de modèle et le XML avec les attributs Xml *.

Il existe un article d'introduction sur la sérialisation XML sur MSDN.

Conseil de performance: la construction d'un XmlSerializerest coûteux. Conservez une référence à votre XmlSerializerinstance si vous avez l'intention d'analyser / écrire plusieurs fichiers XML.

Si vous traitez une grande quantité de données (plusieurs mégaoctets), vous souhaitez utiliser XmlReaderpour analyser le flux XML.

Tout le reste ( XPathNavigator, XElement, XmlDocumentet même XmlSerializersi vous gardez le plein objet graphique généré) se traduira par une utilisation élevée de la mémoire et aussi un temps de chargement très lent.

Bien sûr, si vous avez quand même besoin de toutes les données en mémoire, vous n'aurez peut-être pas beaucoup de choix.

Utilisez XmlTextReader, XmlReader, XmlNodeReaderet l' System.Xml.XPathespace de noms. Et ( XPathNavigator, XPathDocument, XPathExpression, XPathnodeIterator).

Facilite généralement la XPathlecture de XML, ce que vous recherchez peut-être.

Je viens récemment de devoir travailler sur une application qui impliquait l'analyse d'un document XML et je suis d'accord avec Jon Galloway que l'approche basée sur LINQ to XML est, à mon avis, la meilleure. J'ai cependant dû creuser un peu pour trouver des exemples utilisables, donc sans plus tarder, en voici quelques-uns!

Tous les commentaires sont les bienvenus car ce code fonctionne mais n'est peut-être pas parfait et j'aimerais en savoir plus sur l'analyse XML pour ce projet!

public void ParseXML(string filePath)  
{  
    // create document instance using XML file path
    XDocument doc = XDocument.Load(filePath);

    // get the namespace to that within of the XML (xmlns="...")
    XElement root = doc.Root;
    XNamespace ns = root.GetDefaultNamespace();

    // obtain a list of elements with specific tag
    IEnumerable<XElement> elements = from c in doc.Descendants(ns + "exampleTagName") select c;

    // obtain a single element with specific tag (first instance), useful if only expecting one instance of the tag in the target doc
    XElement element = (from c in doc.Descendants(ns + "exampleTagName" select c).First();

    // obtain an element from within an element, same as from doc
    XElement embeddedElement = (from c in element.Descendants(ns + "exampleEmbeddedTagName" select c).First();

    // obtain an attribute from an element
    XAttribute attribute = element.Attribute("exampleAttributeName");
}

Avec ces fonctions, j'ai pu analyser n'importe quel élément et n'importe quel attribut d'un fichier XML sans aucun problème!

Si vous utilisez .NET 2.0, essayez XmlReaderses sous XmlTextReader- classes et XmlValidatingReader. Ils fournissent un moyen rapide et léger (utilisation de la mémoire, etc.), de transférer uniquement un fichier XML.

Si vous avez besoin de XPathcapacités, essayez le XPathNavigator. Si vous avez besoin de l'intégralité du document en mémoire, essayez XmlDocument.

De plus, vous pouvez utiliser le sélecteur XPath de la manière suivante (moyen facile de sélectionner des nœuds spécifiques):

XmlDocument doc = new XmlDocument();
doc.Load("test.xml");

var found = doc.DocumentElement.SelectNodes("//book[@title='Barry Poter']"); // select all Book elements in whole dom, with attribute title with value 'Barry Poter'

// Retrieve your data here or change XML here:
foreach (XmlNode book in nodeList)
{
  book.InnerText="The story began as it was...";
}

Console.WriteLine("Display XML:");
doc.Save(Console.Out);

La documentation

Je ne sais pas s'il existe une "meilleure pratique pour l'analyse XML". Il existe de nombreuses technologies adaptées à différentes situations. Le mode d'utilisation dépend du scénario concret.

Vous pouvez aller avec LINQ pour XML , XmlReader, XPathNavigatorou même des expressions régulières. Si vous expliquez vos besoins, je peux essayer de vous faire quelques suggestions.

Vous pouvez analyser le XML à l'aide de cette bibliothèque System.Xml.Linq. Voici l'exemple de code que j'ai utilisé pour analyser un fichier XML

public CatSubCatList GenerateCategoryListFromProductFeedXML()
{
    string path = System.Web.HttpContext.Current.Server.MapPath(_xmlFilePath);

    XDocument xDoc = XDocument.Load(path);

    XElement xElement = XElement.Parse(xDoc.ToString());


    List<Category> lstCategory = xElement.Elements("Product").Select(d => new Category
    {
        Code = Convert.ToString(d.Element("CategoryCode").Value),
        CategoryPath = d.Element("CategoryPath").Value,
        Name = GetCateOrSubCategory(d.Element("CategoryPath").Value, 0), // Category
        SubCategoryName = GetCateOrSubCategory(d.Element("CategoryPath").Value, 1) // Sub Category
    }).GroupBy(x => new { x.Code, x.SubCategoryName }).Select(x => x.First()).ToList();

    CatSubCatList catSubCatList = GetFinalCategoryListFromXML(lstCategory);

    return catSubCatList;
}

Vous pouvez utiliser ExtendedXmlSerializer pour sérialiser et désérialiser.

Instalation Vous pouvez installer ExtendedXmlSerializer à partir de nuget ou exécuter la commande suivante:

Install-Package ExtendedXmlSerializer

Sérialisation:

ExtendedXmlSerializer serializer = new ExtendedXmlSerializer();
var obj = new Message();
var xml = serializer.Serialize(obj);

Désérialisation

var obj2 = serializer.Deserialize<Message>(xml);

Le sérialiseur XML standard dans .NET est très limité.

• Ne prend pas en charge la sérialisation de classe avec référence circulaire ou de classe avec propriété d'interface,
• Ne prend pas en charge les dictionnaires,
• Il n'y a pas de mécanisme pour lire l'ancienne version de XML,
• Si vous souhaitez créer un sérialiseur personnalisé, votre classe doit hériter d'IXmlSerializable. Cela signifie que votre classe ne sera pas une classe POCO,
• Ne prend pas en charge l'IoC.

ExtendedXmlSerializer peut faire cela et bien plus encore.

ExtendedXmlSerializer prend en charge .NET 4.5 ou supérieur et .NET Core . Vous pouvez l'intégrer à WebApi et AspCore.

Vous pouvez utiliser XmlDocument et pour manipuler ou récupérer des données à partir d'attributs, vous pouvez Linq en classes XML.