Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

XmlSerializer classe

 

Date de publication : novembre 2016

Sérialise et désérialise des objets vers et depuis des documents XML. Le XmlSerializer vous permet de contrôler la manière dont les objets sont encodés en XML.

Espace de noms:   System.Xml.Serialization
Assembly:  System.Xml (dans System.Xml.dll)

System.Object
  System.Xml.Serialization.XmlSerializer

public class XmlSerializer

NomDescription
System_CAPS_protmethodXmlSerializer()

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Initialise une nouvelle instance de la classe XmlSerializer.

System_CAPS_pubmethodXmlSerializer(Type)

Initialise une nouvelle instance de la XmlSerializer documents de classe qui peut sérialiser les objets du type spécifié en documents XML et désérialiser XML en objets du type spécifié.

System_CAPS_pubmethodXmlSerializer(Type, String)

Initialise une nouvelle instance de la XmlSerializer documents de classe qui peut sérialiser les objets du type spécifié en documents XML et désérialiser XML en objets du type spécifié. Spécifie l’espace de noms par défaut pour tous les éléments XML.

System_CAPS_pubmethodXmlSerializer(Type, Type[])

Initialise une nouvelle instance de la XmlSerializer classe qui peut sérialiser les objets du type spécifié en documents XML et désérialiser XML documents en objet du type spécifié. Si une propriété ou un champ retourne un tableau, le extraTypes paramètre spécifie les objets pouvant être insérés dans le tableau.

System_CAPS_pubmethodXmlSerializer(Type, XmlAttributeOverrides)

Initialise une nouvelle instance de la XmlSerializer documents de classe qui peut sérialiser les objets du type spécifié en documents XML et désérialiser XML en objets du type spécifié. Chaque objet à sérialiser peut lui-même contenir des instances de classes auxquelles cette surcharge peut substituer d’autres classes.

System_CAPS_pubmethodXmlSerializer(Type, XmlAttributeOverrides, Type[], XmlRootAttribute, String)

Initialise une nouvelle instance de la XmlSerializer classe qui peut sérialiser les objets de type Object en documents XML et désérialiser les documents XML en objets du type Object. Chaque objet à sérialiser peut lui-même contenir des instances de classes, qui se substitue à cette surcharge avec d’autres classes. Cette surcharge spécifie également l’espace de noms par défaut pour tous les éléments XML et de la classe à utiliser comme élément racine XML.

System_CAPS_pubmethodXmlSerializer(Type, XmlAttributeOverrides, Type[], XmlRootAttribute, String, String)

Initialise une nouvelle instance de la XmlSerializer classe qui peut sérialiser les objets de type Object en documents XML et désérialiser les documents XML en objets du type Object. Chaque objet à sérialiser peut lui-même contenir des instances de classes, qui se substitue à cette surcharge avec d’autres classes. Cette surcharge spécifie également l’espace de noms par défaut pour tous les éléments XML et de la classe à utiliser comme élément racine XML.

System_CAPS_pubmethodXmlSerializer(Type, XmlAttributeOverrides, Type[], XmlRootAttribute, String, String, Evidence)

Obsolète. Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Initialise une nouvelle instance de la XmlSerializer classe qui peut sérialiser les objets du type spécifié en documents XML et désérialiser les documents XML en objets du type spécifié. Cette surcharge vous permet de fournir d’autres types qui peuvent être rencontrés pendant une opération de sérialisation ou la désérialisation, ainsi qu’un espace de noms de tous les éléments XML, la classe à utiliser en tant que l’élément racine XML, son emplacement et les informations d’identification requises pour l’accès.

System_CAPS_pubmethodXmlSerializer(Type, XmlRootAttribute)

Initialise une nouvelle instance de la XmlSerializer classe qui peut sérialiser les objets du type spécifié en documents XML et désérialiser les documents XML en objet du type spécifié. Il spécifie également la classe à utiliser comme élément racine XML.

System_CAPS_pubmethodXmlSerializer(XmlTypeMapping)

Initialise une instance de la XmlSerializer classe à l’aide d’un objet qui mappe un type à un autre.

NomDescription
System_CAPS_pubmethodCanDeserialize(XmlReader)

Obtient une valeur qui indique si cette XmlSerializer peut désérialiser un document XML spécifié.

System_CAPS_protmethodCreateReader()

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Retourne un objet utilisé pour lire le document XML à sérialiser.

System_CAPS_protmethodCreateWriter()

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. En cas de substitution dans une classe dérivée, retourne un writer utilisé pour sérialiser l’objet.

System_CAPS_pubmethodDeserialize(Stream)

Désérialise le document XML contenu par le Stream.

System_CAPS_pubmethodDeserialize(TextReader)

Désérialise le document XML contenu par le TextReader.

System_CAPS_pubmethodDeserialize(XmlReader)

Désérialise le document XML contenu par le XmlReader.

System_CAPS_pubmethodDeserialize(XmlReader, String)

Désérialise le document XML contenu par le XmlReader et le style de codage.

System_CAPS_pubmethodDeserialize(XmlReader, String, XmlDeserializationEvents)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Désérialise l’objet à l’aide des données contenues par le XmlReader.

System_CAPS_pubmethodDeserialize(XmlReader, XmlDeserializationEvents)

Désérialise un document XML contenu par le XmlReader et autorise la substitution des événements qui se produisent pendant la désérialisation.

System_CAPS_protmethodDeserialize(XmlSerializationReader)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Désérialise le document XML contenu par le XmlSerializationReader.

System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_protmethodFinalize()

Autorise un objet à tenter de libérer des ressources et à exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par une opération garbage collection.(Hérité de Object.)

System_CAPS_pubmethodSystem_CAPS_staticFromMappings(XmlMapping[])

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Retourne un tableau de XmlSerializer objets créés à partir d’un tableau de XmlTypeMapping objets.

System_CAPS_pubmethodSystem_CAPS_staticFromMappings(XmlMapping[], Evidence)

Obsolète. Retourne une instance de la XmlSerializer classe créée à partir de mappages d’un type XML à un autre.

System_CAPS_pubmethodSystem_CAPS_staticFromMappings(XmlMapping[], Type)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Retourne une instance de la XmlSerializer classe à partir des mappages spécifiés.

System_CAPS_pubmethodSystem_CAPS_staticFromTypes(Type[])

Retourne un tableau de XmlSerializer objets créés à partir d’un tableau de types.

System_CAPS_pubmethodSystem_CAPS_staticGenerateSerializer(Type[], XmlMapping[])

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Retourne un assembly qui contient des sérialiseurs utilisés pour sérialiser ou désérialiser le type spécifié ou types, à l’aide de mappages spécifiés.

System_CAPS_pubmethodSystem_CAPS_staticGenerateSerializer(Type[], XmlMapping[], CompilerParameters)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Retourne un assembly qui contient des sérialiseurs utilisés pour sérialiser ou désérialiser l’ou les types, à l’aide des mappages spécifiés et les paramètres du compilateur et les options spécifiés.

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodSystem_CAPS_staticGetXmlSerializerAssemblyName(Type)

Retourne le nom de l’assembly qui contient une ou plusieurs versions de la XmlSerializer créé spécialement pour sérialiser ou désérialiser le type spécifié.

System_CAPS_pubmethodSystem_CAPS_staticGetXmlSerializerAssemblyName(Type, String)

Retourne le nom de l’assembly qui contient le sérialiseur pour le type spécifié dans l’espace de noms spécifié.

System_CAPS_protmethodMemberwiseClone()

Crée une copie superficielle du Object actuel.(Hérité de Object.)

System_CAPS_protmethodSerialize(Object, XmlSerializationWriter)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Sérialise spécifié Object et écrit le document XML dans un fichier à l’aide du XmlSerializationWriter.

System_CAPS_pubmethodSerialize(Stream, Object)

Sérialise spécifié Object et écrit le document XML dans un fichier à l’aide du Stream.

System_CAPS_pubmethodSerialize(Stream, Object, XmlSerializerNamespaces)

Sérialise spécifié Object et écrit le document XML dans un fichier à l’aide de la Streamqui fait référence à des espaces de noms spécifiés.

System_CAPS_pubmethodSerialize(TextWriter, Object)

Sérialise spécifié Object et écrit le document XML dans un fichier à l’aide du TextWriter.

System_CAPS_pubmethodSerialize(TextWriter, Object, XmlSerializerNamespaces)

Sérialise spécifié Object et écrit le document XML dans un fichier à l’aide de la TextWriter et fait référence à des espaces de noms spécifiés.

System_CAPS_pubmethodSerialize(XmlWriter, Object)

Sérialise spécifié Object et écrit le document XML dans un fichier à l’aide du XmlWriter.

System_CAPS_pubmethodSerialize(XmlWriter, Object, XmlSerializerNamespaces)

Sérialise spécifié Object et écrit le document XML dans un fichier à l’aide de la XmlWriter et fait référence à des espaces de noms spécifiés.

System_CAPS_pubmethodSerialize(XmlWriter, Object, XmlSerializerNamespaces, String)

Sérialise l’objet spécifié et écrit le document XML dans un fichier à l’aide de la XmlWriter et référence les espaces de noms spécifiés et le style de codage.

System_CAPS_pubmethodSerialize(XmlWriter, Object, XmlSerializerNamespaces, String, String)

Sérialise spécifié Object et écrit le document XML dans un fichier à l’aide de la XmlWriter, espaces de noms XML et le codage.

System_CAPS_pubmethodToString()

Retourne une chaîne qui représente l'objet actuel.(Hérité de Object.)

NomDescription
System_CAPS_pubeventUnknownAttribute

Se produit lorsque le XmlSerializer rencontre un attribut XML de type inconnu lors de la désérialisation.

System_CAPS_pubeventUnknownElement

Se produit lorsque le XmlSerializer rencontre un élément XML de type inconnu lors de la désérialisation.

System_CAPS_pubeventUnknownNode

Se produit lorsque le XmlSerializer rencontre un nœud XML de type inconnu lors de la désérialisation.

System_CAPS_pubeventUnreferencedObject

Se produit pendant la désérialisation d’un flux XML encodé selon le protocole, lorsque la XmlSerializer rencontre un type reconnu n’est pas utilisé ou non référencé.

La sérialisation XML est le processus qui consiste à convertir des propriétés et champs publics d'un objet dans un format série (dans ce cas, XML) à des fins de stockage et de transport. La désérialisation recrée l’objet dans son état d’origine à partir de la sortie XML. Vous pouvez considérer de sérialisation comme un moyen d’enregistrer l’état d’un objet dans un flux ou une mémoire tampon. Par exemple, ASP.NET utilise le XmlSerializer classe pour encoder les messages de service Web XML.

Les données de vos objets sont décrites à l'aide des constructions d'un langage de programmation, telles que les classes, les champs, les propriétés, les types primitifs, les tableaux voire du code XML incorporé sous forme d'objets XmlElement ou XmlAttribute. Vous avez la possibilité de créer vos propres classes, annotées avec des attributs, ou à l’aide de la Outil XML Schema Definition (Xsd.exe) pour générer les classes basées sur un document XML Schema definition (XSD). Si vous avez un schéma XML, vous pouvez exécuter Xsd.exe pour produire un ensemble de classes fortement typées sur le schéma et annotées avec des attributs à respecter le schéma lorsqu’il est sérialisé.

Pour transférer des données entre les objets et XML requiert un mappage dans les constructions de langage de programmation pour le schéma XML et du schéma XML pour les constructions de langage de programmation. Le XmlSerializer et les outils associés tels que Xsd.exe, proposent une passerelle entre ces deux technologies au moment du design et le runtime. Au moment du design, utilisez Xsd.exe pour produire un document de schéma XML (.xsd) à partir de vos classes personnalisées ou pour générer des classes à partir d’un schéma donné. Dans les deux cas, les classes sont annotées avec des attributs personnalisés qui indiquent à la XmlSerializer le mappage entre le système de schémas XML et le common language runtime. Lors de l’exécution, les instances des classes peuvent être sérialisées en documents XML respectant le schéma donné. De même, ces documents XML peuvent être désérialisés en objets d’exécution. Notez que le schéma XML est facultatif et non requis au moment de la conception ou d’exécution.

Pour contrôler le code XML généré, vous pouvez appliquer des attributs spéciaux aux classes et membres. Par exemple, pour spécifier un autre nom d’élément XML, appliquez une XmlElementAttribute à un champ public ou une propriété et un ensemble le ElementName propriété. Pour obtenir une liste complète des attributs similaires, consultez Attributs qui contrôlent la sérialisation XML. Vous pouvez également implémenter le IXmlSerializable interface pour contrôler la sortie XML.

Si le code XML généré doit se conformer à la section 5 du document du World Wide Consortium (www.w3.org), « Simple Object Access Protocol (SOAP) 1.1 », vous devez construire le XmlSerializer avec un XmlTypeMapping. Pour mieux contrôler le langage XML SOAP codé, utilisez les attributs répertoriés dans Attributs qui contrôlent la sérialisation encodée selon le protocole SOAP.

Avec le XmlSerializer vous pouvez tirer parti de l’utilisation des classes fortement typées et ont toujours la possibilité de XML. À l’aide des champs ou des propriétés de type XmlElement, XmlAttribute ou XmlNode dans vos classes fortement typées, vous pouvez lire des parties du document XML directement dans des objets XML.

Si vous travaillez avec des schémas XML extensibles, vous pouvez également utiliser le XmlAnyElementAttribute et XmlAnyAttributeAttribute attributs pour sérialiser et désérialiser des éléments ou des attributs qui ne figurent pas dans le schéma d’origine. Pour utiliser les objets, appliquez une XmlAnyElementAttribute à un champ qui retourne un tableau de XmlElement des objets ou appliquer un XmlAnyAttributeAttribute à un champ qui retourne un tableau de XmlAttribute objets.

Si une propriété ou un champ retourne un objet complexe (tel qu'un tableau ou une instance de classe), XmlSerializer le convertit en élément imbriqué dans le document XML principal. Par exemple, la première classe dans le code suivant retourne une instance de la deuxième classe.

public class MyClass
{
    public MyObject MyObjectProperty;
}
public class MyObject
{
    public string ObjectName;
}

La sérialisation, sortie XML ressemble à ceci :

<MyClass>
  <MyObjectProperty>
  <ObjectName>My String</ObjectName>
  </MyObjectProperty>
</MyClass>

Si un schéma comporte un élément facultatif (minOccurs = '0'), ou si le schéma inclut une valeur par défaut, vous avez deux options. Une option consiste à utiliser System.ComponentModel.DefaultValueAttribute pour spécifier la valeur par défaut, comme indiqué dans le code suivant.

public class PurchaseOrder
{
    [System.ComponentModel.DefaultValueAttribute ("2002")]
    public string Year;
}

Une autre option consiste à utiliser un modèle spécifique pour créer un champ booléen reconnu par le XmlSerializer, et d’appliquer les XmlIgnoreAttribute au champ. Le modèle est créé sous la forme de propertyNameSpecified. Par exemple, s’il est un champ nommé « MyFirstName », vous allez également créer un champ « MyFirstNameSpecified » qui indique la XmlSerializer s’il faut générer un élément XML nommé « MyFirstName ». L'exemple suivant le démontre.

public class OptionalOrder
{
    // This field should not be serialized 
    // if it is uninitialized.
    public string FirstOrder;

    // Use the XmlIgnoreAttribute to ignore the 
    // special field named "FirstOrderSpecified".
    [System.Xml.Serialization.XmlIgnoreAttribute]
    public bool FirstOrderSpecified;
}

Vous pouvez également substituer la sérialisation d’un jeu d’objets et de leurs champs et propriétés en créant un des attributs appropriés, puis ajoutez-le à une instance de la XmlAttributes classe. Substituer la sérialisation de cette manière a deux utilisations : tout d’abord, vous pouvez contrôler et augmenter la sérialisation d’objets trouvés dans une DLL, même si vous n’avez pas accès à la source ; Ensuite, vous pouvez créer un ensemble de classes sérialisables, mais sérialiser les objets de plusieurs façons. Pour plus d’informations, consultez la XmlAttributeOverrides classe et Comment : contrôler la sérialisation de classes dérivées.

Pour sérialiser un objet, appelez le Serialize (méthode). Pour désérialiser un objet, appelez le Deserialize (méthode).

Pour ajouter des espaces de noms XML à un document XML, consultez XmlSerializerNamespaces.

System_CAPS_noteRemarque

Le XmlSerializer offre un traitement spécial aux classes qui implémentent IEnumerable ou ICollection. Une classe qui implémente IEnumerable doit implémenter une méthode Add publique n'acceptant qu'un paramètre. Le Add paramètre de la méthode doit être du même type que celui retourné par le Current propriété sur la valeur retournée par GetEnumerator, ou l’une des bases de ce type. Une classe qui implémente ICollection (tel que CollectionBase) en plus de IEnumerable doit avoir un public Item propriété indexée (indexeur en c#) qui prend un entier, et il doit avoir un public Count propriété de type entier. Le paramètre de la Add méthode doit être du même type que celui retourné par le Item propriété ou l’une des bases de ce type. Pour les classes qui implémentent ICollection, les valeurs à sérialiser sont récupérées à partir de la liste indexée Item propriété, ne pas en appelant GetEnumerator.

Vous devez disposer des autorisations pour écrire dans le répertoire temporaire (comme défini par la variable d’environnement TEMP) désérialiser un objet.

Pour améliorer les performances, l’infrastructure de sérialisation XML génère dynamiquement des assemblys pour sérialiser et désérialiser des types spécifiés. L’infrastructure recherche et réutilise ces assemblys. Ce comportement se produit uniquement lorsque vous utilisez les constructeurs suivants :

XmlSerializer.XmlSerializer(Type)

XmlSerializer.XmlSerializer(Type, String)

Si vous utilisez un des autres constructeurs, plusieurs versions du même assembly sont générées et jamais déchargées, ce qui aboutit à une fuite de mémoire et de performances médiocres. La solution la plus simple consiste à utiliser un des deux constructeurs mentionnés précédemment. Dans le cas contraire, vous devez mettre en cache les assemblys dans un Hashtable, comme illustré dans l’exemple suivant.

Hashtable serializers = new Hashtable();

// Use the constructor that takes a type and XmlRootAttribute.
XmlSerializer s = new XmlSerializer(typeof(MyClass), myRoot);

// Implement a method named GenerateKey that creates unique keys 
// for each instance of the XmlSerializer. The code should take 
// into account all parameters passed to the XmlSerializer 
// constructor.
object key = GenerateKey(typeof(MyClass), myRoot);

// Check the local cache for a matching serializer.
XmlSerializer ser = (XmlSerializer)serializers[key];
if (ser == null) 
{
    ser = new XmlSerializer(typeof(MyClass), myRoot);
    // Cache the serializer.
    serializers[key] = ser;
}
else
{
    // Use the serializer to serialize, or deserialize.
}

Le XmlSerializer ne peut pas sérialiser ou désérialiser les éléments suivants :

Le XmlSerializer ne peut pas être instancié pour sérialiser une énumération si les conditions suivantes sont remplies : l’énumération est de type long non signé (ulong en c#) et l’énumération contient des membres ayant une valeur supérieure à 9,223,372,036,854,775,807. Par exemple, les éléments suivants ne peuvent pas être sérialisés.

public enum LargeNumbers: ulong
{
    a = 9223372036854775808
}
// At runtime, the following code will fail.
xmlSerializer mySerializer=new XmlSerializer(typeof(LargeNumbers));

Dans la .NET Framework 3.5 la XmlSerializer classe ne sérialise plus les objets qui sont marqués comme [Obsolete].

L’exemple suivant contient deux classes principales : PurchaseOrder et Test. La PurchaseOrder classe contient des informations sur une seule commande. La Test classe contient les méthodes qui créent le bon de commande et lisent le bon de commande créé.

using System;
using System.Xml;
using System.Xml.Serialization;
using System.IO;

/* The XmlRootAttribute allows you to set an alternate name 
   (PurchaseOrder) of the XML element, the element namespace; by 
   default, the XmlSerializer uses the class name. The attribute 
   also allows you to set the XML namespace for the element.  Lastly,
   the attribute sets the IsNullable property, which specifies whether 
   the xsi:null attribute appears if the class instance is set to 
   a null reference. */
[XmlRootAttribute("PurchaseOrder", Namespace="http://www.cpandl.com", 
IsNullable = false)]
public class PurchaseOrder
{
   public Address ShipTo;
   public string OrderDate; 
   /* The XmlArrayAttribute changes the XML element name
    from the default of "OrderedItems" to "Items". */
   [XmlArrayAttribute("Items")]
   public OrderedItem[] OrderedItems;
   public decimal SubTotal;
   public decimal ShipCost;
   public decimal TotalCost;   
}

public class Address
{
   /* The XmlAttribute instructs the XmlSerializer to serialize the Name
      field as an XML attribute instead of an XML element (the default
      behavior). */
   [XmlAttribute]
   public string Name;
   public string Line1;

   /* Setting the IsNullable property to false instructs the 
      XmlSerializer that the XML attribute will not appear if 
      the City field is set to a null reference. */
   [XmlElementAttribute(IsNullable = false)]
   public string City;
   public string State;
   public string Zip;
}

public class OrderedItem
{
   public string ItemName;
   public string Description;
   public decimal UnitPrice;
   public int Quantity;
   public decimal LineTotal;

   /* Calculate is a custom method that calculates the price per item,
      and stores the value in a field. */
   public void Calculate()
   {
      LineTotal = UnitPrice * Quantity;
   }
}

public class Test
{
   public static void Main()
   {
      // Read and write purchase orders.
      Test t = new Test();
      t.CreatePO("po.xml");
      t.ReadPO("po.xml");
   }

   private void CreatePO(string filename)
   {
      // Create an instance of the XmlSerializer class;
      // specify the type of object to serialize.
      XmlSerializer serializer = 
      new XmlSerializer(typeof(PurchaseOrder));
      TextWriter writer = new StreamWriter(filename);
      PurchaseOrder po=new PurchaseOrder();

      // Create an address to ship and bill to.
      Address billAddress = new Address();
      billAddress.Name = "Teresa Atkinson";
      billAddress.Line1 = "1 Main St.";
      billAddress.City = "AnyTown";
      billAddress.State = "WA";
      billAddress.Zip = "00000";
      // Set ShipTo and BillTo to the same addressee.
      po.ShipTo = billAddress;
      po.OrderDate = System.DateTime.Now.ToLongDateString();

      // Create an OrderedItem object.
      OrderedItem i1 = new OrderedItem();
      i1.ItemName = "Widget S";
      i1.Description = "Small widget";
      i1.UnitPrice = (decimal) 5.23;
      i1.Quantity = 3;
      i1.Calculate();

      // Insert the item into the array.
      OrderedItem [] items = {i1};
      po.OrderedItems = items;
      // Calculate the total cost.
      decimal subTotal = new decimal();
      foreach(OrderedItem oi in items)
      {
         subTotal += oi.LineTotal;
      }
      po.SubTotal = subTotal;
      po.ShipCost = (decimal) 12.51; 
      po.TotalCost = po.SubTotal + po.ShipCost; 
      // Serialize the purchase order, and close the TextWriter.
      serializer.Serialize(writer, po);
      writer.Close();
   }

   protected void ReadPO(string filename)
   {
      // Create an instance of the XmlSerializer class;
      // specify the type of object to be deserialized.
      XmlSerializer serializer = new XmlSerializer(typeof(PurchaseOrder));
      /* If the XML document has been altered with unknown 
      nodes or attributes, handle them with the 
      UnknownNode and UnknownAttribute events.*/
      serializer.UnknownNode+= new 
      XmlNodeEventHandler(serializer_UnknownNode);
      serializer.UnknownAttribute+= new 
      XmlAttributeEventHandler(serializer_UnknownAttribute);

      // A FileStream is needed to read the XML document.
      FileStream fs = new FileStream(filename, FileMode.Open);
      // Declare an object variable of the type to be deserialized.
      PurchaseOrder po;
      /* Use the Deserialize method to restore the object's state with
      data from the XML document. */
      po = (PurchaseOrder) serializer.Deserialize(fs);
      // Read the order date.
      Console.WriteLine ("OrderDate: " + po.OrderDate);

      // Read the shipping address.
      Address shipTo = po.ShipTo;
      ReadAddress(shipTo, "Ship To:");
      // Read the list of ordered items.
      OrderedItem [] items = po.OrderedItems;
      Console.WriteLine("Items to be shipped:");
      foreach(OrderedItem oi in items)
      {
         Console.WriteLine("\t"+
         oi.ItemName + "\t" + 
         oi.Description + "\t" +
         oi.UnitPrice + "\t" +
         oi.Quantity + "\t" +
         oi.LineTotal);
      }
      // Read the subtotal, shipping cost, and total cost.
      Console.WriteLine("\t\t\t\t\t Subtotal\t" + po.SubTotal);
      Console.WriteLine("\t\t\t\t\t Shipping\t" + po.ShipCost); 
      Console.WriteLine("\t\t\t\t\t Total\t\t" + po.TotalCost);
   }

   protected void ReadAddress(Address a, string label)
   {
      // Read the fields of the Address object.
      Console.WriteLine(label);
      Console.WriteLine("\t"+ a.Name );
      Console.WriteLine("\t" + a.Line1);
      Console.WriteLine("\t" + a.City);
      Console.WriteLine("\t" + a.State);
      Console.WriteLine("\t" + a.Zip );
      Console.WriteLine();
   }

   private void serializer_UnknownNode
   (object sender, XmlNodeEventArgs e)
   {
      Console.WriteLine("Unknown Node:" +   e.Name + "\t" + e.Text);
   }

   private void serializer_UnknownAttribute
   (object sender, XmlAttributeEventArgs e)
   {
      System.Xml.XmlAttribute attr = e.Attr;
      Console.WriteLine("Unknown attribute " + 
      attr.Name + "='" + attr.Value + "'");
   }
}

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 1.1
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1

Ce type est thread-safe.

Retour au début
Afficher: