Quelle est la meilleure façon d'analyser manuellement un objet XElement en objets personnalisés?

Question

J'ai une variable XElement nommé contenu qui comprend le code XML suivant:

<content> 
    <title>Contact Data</title> 
    <p>This is a paragraph this will be displayed in front of the first form.</p> 
    <form idCode="contactData" query="limit 10; category=internal"/> 
    <form idCode="contactDataDetail" query="limit 10; category=internal"> 
     <title>Contact Data Detail</title> 
     <description>This is the detail information</description> 
    </form> 
</content> 

Je veux maintenant simplement course à travers chacun des nœuds de niveau 1 et les objets en parse. Retour en C# 2.0 je l'utilise pour faire XmlReader, vérifier le type de nœud, et l'analyser en conséquence.

Mais quelle est la meilleure façon d'analyser les noeuds XML avec LINQ, je me attends quelque chose comme ceci:

var contentItems = from contentItem in pageItem.content.DescendantNodes() 
        select new ContentItem 
        { 
         Type = contentItem.Element() 
        }; 

foreach (var contentItem in contentItems) 
{ 
    switch (contentItem.Type) 
    { 
     case "title": 
      ...(parse title)... 
     case "p": 
      ...(parse p)... 
     case "form": 
      ...(parse form)... 
    } 
} 

où:

public class ContentItem 
{ 
    public string Type { get; set; } 
    public string IdCode { get; set; } 
    public XElement Content { get; set; } 
} 

Answer 1

-t-il être XElement? Je (soit manuellement, soit via xsd.exe) il suffit de créer des classes qui correspondent aux noms d'éléments/attributs - et utiliser XmlSerializer - notamment via StringReader:

 Content content; 
     using(StringReader sr = new StringReader(xml)) 
     using(XmlReader xr = XmlReader.Create(sr)) { 
      XmlSerializer ser = new XmlSerializer(typeof(Content)); 
      content = (Content)ser.Deserialize(xr); 
     } 

(modifier) ​​

Avec les classes d'entités :

[XmlRoot("content")] 
public class Content { 
    [XmlElement("title")] 
    public string Title { get; set; } 
    [XmlElement("p")] 
    public string Description { get; set; } 
    [XmlElement("form")] 
    public List<ContentForm> Forms { get; set; } 
}  
public class ContentForm { 
    [XmlAttribute("idCode")] 
    public string Id { get; set; } 
    [XmlAttribute("query")] 
    public string Query { get; set; } 
    [XmlElement("title")] 
    public string Title { get; set; } 
    [XmlElement("description")] 
    public string Description { get; set; } 
} 

Answer 2

Avec XML à un LINQ tractions éléments de données spécifiques sur le XML, plutôt que par le XML itérer à la recherche de ce qui est trouvé.

var results = from node in XmlDocument.SomeContext(...) 
       select new MyType { 
       Prop1 = node.Element("One").Value, 
       Prop2 = node.Element("One").Attributes().Where(
         a => A.Value.Contains("Foo").Value 
      }; 

Si les conditions sont nécessaires, alors (extension) des méthodes et des expressions arbitraires peuvent être utilisés (opérateur null-coalescent, ??, peut être très utile par défaut).

Answer 3

Je suggérerais d'hériter de XElement et d'implémenter des propriétés pour les choses que vous voulez. Ces propriétés ne doivent pas utiliser de champs de support, mais plutôt travailler directement avec l'élément XML sous-jacent. De cette façon, vous garderez l'objet en synchronisation avec XML.