écrire une classe XML DeSerialization plus simple pour le fichier xml le plus simple. Comment éviter la nidification? désérialiser à la racine?

Question

Je veux désérialiser un fichier xml qui doit être juste sous cette forme

<Basket> 
    <Fruit>Apple</Fruit> 
    <Fruit>Orange</Fruit> 
    <Fruit>Grapes</Fruit> 
</Basket> 

Sur les exemples que je lis sur Internet le format le moins possible, je pouvais trouver AVAIT

<Basket> 
    <FruitArray> 
    <Fruit>Apple</Fruit> 
    </FruitArray> 
    <FruitArray> 
    <Fruit>Orange</Fruit> 
    </FruitArray> 
    <FruitArray> 
    <Fruit>Grapes</Fruit> 
    </FruitArray> 
</Basket> 

et qui a la classe de désérialisation suivante pour le convertir en un objet de classe.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 

namespace XMLSerialization_Basket 
{ 
    [System.Xml.Serialization.XmlRootAttribute("Basket", Namespace = "BasketNamespace", IsNullable = false)] 
    public class Basket 
    { 
     /// <remarks/> 
     [System.Xml.Serialization.XmlElementAttribute("FruitArray")] 
     public FruitArray[] objFruitArray; 
    } 

    /// <remarks/> 
    [System.Xml.Serialization.XmlTypeAttribute(Namespace = "BasketNamespace")] 
    public class FruitArray 
    { 

     /// <remarks/> 
     private string _Fruit; 

     public string Fruit 
     { 

      get { return _Fruit; } 
      set { _Fruit = value; } 
     } 
    } 


} 

Puis-je ajouter quelque chose comme ce qui suit directement sous classe supérieure

private string _Fruit; 

    public string Fruit 
    { 

     get { return _Fruit; } 
     set { _Fruit = value; } 
    } 

et éviter l'imbrication tableau?

mon objectif est de désérialiser un xml de format suivant

<Basket> 
    <Fruit>Apple</Fruit> 
    <Fruit>Orange</Fruit> 
    <Fruit>Grapes</Fruit> 
</Basket> 

Answer 1

Vous devez juste besoin:

public class Basket { 
    private List<string> fruits = new List<string>(); 
    [XmlElement("Fruit")] 
    public List<string> Fruits {get {return fruits;}} 
} 

Answer 2

Avec tout le respect que je modifierais mon XML et objet à désérialiser dans ce qui suit.

Voici le C# (devrait compiler;))

using System.Xml.Serialization; 
    using System.Xml.Schema; 
    [XmlRootAttribute(Namespace = "", IsNullable = false)] 
    public class Basket 
    { 
     [XmlArrayAttribute("Fruits", Form = XmlSchemaForm.Unqualified)] 
     [XmlArrayItemAttribute("Fruit", typeof(string), Form = XmlSchemaForm.Unqualified)] 
     public List<string> _items; 
    } 

Voici le XML

<Basket> 
    <Fruits> 
    <Fruit>Apple</Fruit> 
    <Fruit>Orange</Fruit> 
    <Fruit>Grapes</Fruit> 
    </Fruits> 
</Basket> 

Answer 3

[XmlRoot("Basket")] 
class Basket : List<Fruit> 
{ 

} 

[XmlRoot("Fruit")] 
class Fruit 
{ 
    [XmlText] 
    string Value { get; set; } 
} 

Ou LINQ pour XML:

public void Serialize(Basket b) 
{ 
    XElement _root = new XElement("Basket", 
     b.Select(
      f => new XElement("Fruit", 
       new XText(f.Value)))); 

    _root.Save("file.xml"); 
} 

public void Deserialize() 
{ 
    Basket b = new Basket(); 

    XElement _root = XElement.Load("file.xml"); 
    foreach(XElement fruit in _root.Descendants("Fruit")) 
    { 
     Fruit f = new Fruit(); 
     f.Value = fruit.Value; 
     basket.Add(f); 
    } 
} 

Answer 4

Le précédent poste absolument travaillé ...

public class Basket { 
    private List<string> fruits = new List<string>(); 
    [XmlElement("Fruit")] 
    public List<string> Fruits {get {return fruits;}} 
} 

J'ai mis en place le banc d'essai suivant et il était capable de lire le XML indiqué sans problème.

var doc = new XmlDocument(); 
doc.Load("TheFile.xml"); 

var basket = XmlDeserialize<Basket>(doc.OuterXml); 

public static T XmlDeserialize<T>(string serializedContent) 
{ 
    T returnValue; 

    if (String.IsNullOrEmpty(serializedContent)) 
    { 
     returnValue = default(T); 
    } 
    else 
    { 
     var deSerializer = new XmlSerializer(typeof(T)); 
     var stringReader = new StringReader(serializedContent); 

     try 
     { 
      returnValue = (T)deSerializer.Deserialize(stringReader); 
     } 
     catch (InvalidOperationException) 
     { 
      returnValue = default(T); 
     } 
    } 

    return returnValue; 
} 

Answer 5

C'est ce que le schéma XML devrait ressembler à:

<?xml version="1.0" encoding="utf-8"?> 
<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema"> 
    <xs:element name="Basket"> 
    <xs:complexType> 
     <xs:sequence> 
     <xs:element maxOccurs="unbounded" name="Fruit" type="xs:string" /> 
     </xs:sequence> 
    </xs:complexType> 
    </xs:element> 
</xs:schema> 

Si vous enregistrez le xsd (Appelons juste sample.xsd) et exécutez xsd avec les paramètres suivants:

xsd.exe /c /n:BasketOfFruits sample.xsd 

Vous aurez cette classe:

namespace BasketOfFruits { 
    using System.Xml.Serialization; 


    /// <remarks/> 
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "2.0.50727.1432")] 
    [System.SerializableAttribute()] 
    [System.Diagnostics.DebuggerStepThroughAttribute()] 
    [System.ComponentModel.DesignerCategoryAttribute("code")] 
    [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)] 
    [System.Xml.Serialization.XmlRootAttribute(Namespace="", IsNullable=false)] 
    public partial class Basket { 

     private string[] fruitField; 

     /// <remarks/> 
     [System.Xml.Serialization.XmlElementAttribute("Fruit")] 
     public string[] Fruit { 
      get { 
       return this.fruitField; 
      } 
      set { 
       this.fruitField = value; 
      } 
     } 
    } 
} 

Voici un exemple de programme pour démontrer:

using System; 
using System.Text; 
using System.Xml; 
using System.Xml.Serialization; 
using BasketOfFruits; 

namespace ConsoleApplication1 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      Basket myBasket = new Basket(); 
      myBasket.Fruit = new string[] { "Apple", "Orange", "Grapes" }; 

      XmlSerializer xs = new XmlSerializer(typeof(Basket));    
      XmlSerializerNamespaces emptyNamespace = new XmlSerializerNamespaces(); 
      emptyNamespace.Add(String.Empty, String.Empty); 

      StringBuilder output = new StringBuilder(); 

      XmlWriter writer = XmlWriter.Create(output, 
       new XmlWriterSettings { OmitXmlDeclaration = true, Indent = true }); 
      xs.Serialize(writer, myBasket, emptyNamespace); 

      Console.WriteLine(output.ToString()); 

      // pause program execution to review results... 
      Console.WriteLine("Press enter to exit"); 
      Console.ReadLine(); 
     } 
    } 
} 

qui sérialisera à ceci:

<Basket> 
    <Fruit>Apple</Fruit> 
    <Fruit>Orange</Fruit> 
    <Fruit>Grapes</Fruit> 
</Basket>