DataContractSerializer Classe

Définition

Sérialise et désérialise une instance d'un type dans un flux ou un document XML à l'aide d'un contrat de données fourni. Cette classe ne peut pas être héritée.

public ref class DataContractSerializer sealed : System::Runtime::Serialization::XmlObjectSerializer
public sealed class DataContractSerializer : System.Runtime.Serialization.XmlObjectSerializer
type DataContractSerializer = class
    inherit XmlObjectSerializer
Public NotInheritable Class DataContractSerializer
Inherits XmlObjectSerializer
Héritage
DataContractSerializer

Exemples

L'exemple de code suivant affiche un type nommé Person qui est sérialisé par le DataContractSerializer. L'attribut DataContractAttribute est appliqué à la classe, et l'attribut DataMemberAttribute est appliqué aux membres pour indiquer à la classe DataContractSerializer l'élément à sérialiser.

namespace DataContractSerializerExample
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Runtime.Serialization;
    using System.Xml;

    // You must apply a DataContractAttribute or SerializableAttribute
    // to a class to have it serialized by the DataContractSerializer.
    [DataContract(Name = "Customer", Namespace = "http://www.contoso.com")]
    class Person : IExtensibleDataObject
    {
        [DataMember()]
        public string FirstName;
        [DataMember]
        public string LastName;
        [DataMember()]
        public int ID;

        public Person(string newfName, string newLName, int newID)
        {
            FirstName = newfName;
            LastName = newLName;
            ID = newID;
        }

        private ExtensionDataObject extensionData_Value;

        public ExtensionDataObject ExtensionData
        {
            get
            {
                return extensionData_Value;
            }
            set
            {
                extensionData_Value = value;
            }
        }
    }

    public sealed class Test
    {
        private Test() { }

        public static void Main()
        {
            try
            {
                WriteObject("DataContractSerializerExample.xml");
                ReadObject("DataContractSerializerExample.xml");
            }

            catch (SerializationException serExc)
            {
                Console.WriteLine("Serialization Failed");
                Console.WriteLine(serExc.Message);
            }
            catch (Exception exc)
            {
                Console.WriteLine(
                "The serialization operation failed: {0} StackTrace: {1}",
                exc.Message, exc.StackTrace);
            }

            finally
            {
                Console.WriteLine("Press <Enter> to exit....");
                Console.ReadLine();
            }
        }

        public static void WriteObject(string fileName)
        {
            Console.WriteLine(
                "Creating a Person object and serializing it.");
            Person p1 = new Person("Zighetti", "Barbara", 101);
            FileStream writer = new FileStream(fileName, FileMode.Create);
            DataContractSerializer ser =
                new DataContractSerializer(typeof(Person));
            ser.WriteObject(writer, p1);
            writer.Close();
        }

        public static void ReadObject(string fileName)
        {
            Console.WriteLine("Deserializing an instance of the object.");
            FileStream fs = new FileStream(fileName,
            FileMode.Open);
            XmlDictionaryReader reader =
                XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());
            DataContractSerializer ser = new DataContractSerializer(typeof(Person));

            // Deserialize the data and read it from the instance.
            Person deserializedPerson =
                (Person)ser.ReadObject(reader, true);
            reader.Close();
            fs.Close();
            Console.WriteLine(String.Format("{0} {1}, ID: {2}",
            deserializedPerson.FirstName, deserializedPerson.LastName,
            deserializedPerson.ID));
        }
    }
' You must apply a DataContractAttribute or SerializableAttribute
' to a class to have it serialized by the DataContractSerializer.
<DataContract(Name := "Customer", [Namespace] := "http://www.contoso.com")>  _
Class Person
    Implements IExtensibleDataObject
    <DataMember()>  _
    Public FirstName As String
    <DataMember()>  _
    Public LastName As String
    <DataMember()>  _
    Public ID As Integer
    
    Public Sub New(ByVal newfName As String, ByVal newLName As String, ByVal newID As Integer) 
        FirstName = newfName
        LastName = newLName
        ID = newID
    End Sub 
    
    Private extensionData_Value As ExtensionDataObject
    
    Public Property ExtensionData() As ExtensionDataObject Implements _
       IExtensibleDataObject.ExtensionData
        Get
            Return extensionData_Value
        End Get
        Set
            extensionData_Value = value
        End Set
    End Property
End Class 


NotInheritable Public Class Test
    
    Private Sub New() 
    
    End Sub 
     
    Public Shared Sub Main() 
        Try
            WriteObject("DataContractSerializerExample.xml")
            ReadObject("DataContractSerializerExample.xml")
        
        Catch serExc As SerializationException
            Console.WriteLine("Serialization Failed")
            Console.WriteLine(serExc.Message)
        Catch exc As Exception
            Console.WriteLine("The serialization operation failed: {0} StackTrace: {1}", exc.Message, exc.StackTrace)
        
        Finally
            Console.WriteLine("Press <Enter> to exit....")
            Console.ReadLine()
        End Try
    End Sub 
    
    Public Shared Sub WriteObject(ByVal fileName As String) 
        Console.WriteLine("Creating a Person object and serializing it.")
        Dim p1 As New Person("Zighetti", "Barbara", 101)
        Dim writer As New FileStream(fileName, FileMode.Create)
        Dim ser As New DataContractSerializer(GetType(Person))
        ser.WriteObject(writer, p1)
        writer.Close()
    End Sub 

    Public Shared Sub ReadObject(ByVal fileName As String) 
        Console.WriteLine("Deserializing an instance of the object.")
        Dim fs As New FileStream(fileName, FileMode.Open)
        Dim reader As XmlDictionaryReader = _
            XmlDictionaryReader.CreateTextReader(fs, New XmlDictionaryReaderQuotas())
        Dim ser As New DataContractSerializer(GetType(Person))
        
        ' Deserialize the data and read it from the instance.
        Dim deserializedPerson As Person = CType(ser.ReadObject(reader, True), Person)
        reader.Close()
        fs.Close()
        Console.WriteLine(String.Format("{0} {1}, ID: {2}", deserializedPerson.FirstName, deserializedPerson.LastName, deserializedPerson.ID))
    End Sub 
End Class

Remarques

Utilisez la classe DataContractSerializer pour sérialiser et désérialiser des instances d'un type dans un flux ou un document XML. Par exemple, vous pouvez créer un type nommé Person avec des propriétés qui contiennent des données essentielles, telles qu'un nom et une adresse. Vous pouvez créer ensuite et manipuler une instance de la classe Person et écrire toutes ses valeurs de propriété dans un document XML en vue de récupération ultérieure, ou dans un flux XML pour un transport immédiat. Plus important encore, le DataContractSerializer est utilisé pour sérialiser et désérialiser les données envoyées dans les messages Windows Communication Foundation (WCF). Appliquez l'attribut DataContractAttribute aux classes, et l'attribut DataMemberAttribute aux membres des classes pour spécifier les propriétés et les champs sérialisés.

Pour obtenir la liste des types qui peuvent être sérialisés, consultez Types pris en charge par le sérialiseur de contrat de données.

Pour utiliser la classe DataContractSerializer, créez d'abord une instance d'une classe et un objet apte à écrire ou lire le format ; par exemple, une instance de la classe XmlDictionaryWriter. Appelez ensuite la méthode WriteObject pour rendre les données persistantes. Pour récupérer des données, créez un objet apte à lire le format de données (par exemple, une classe XmlDictionaryReader pour un document XML) et appelez la méthode ReadObject.

Pour plus d’informations sur l’utilisation de DataContractSerializer, consultez Sérialisation et désérialisation.

Vous pouvez définir le type d’un sérialiseur de contrat de données à l’aide de l’élément< dataContractSerializer> dans un fichier de configuration d’application cliente.

Préparation de classes pour la sérialisation ou la désérialisation

La classe DataContractSerializer est utilisée en association avec les DataContractAttribute et DataMemberAttribute. Pour préparer une classe à la sérialisation, appliquez DataContractAttribute à la classe. Pour chaque membre de la classe qui retourne des données que vous voulez sérialiser, appliquez DataMemberAttribute. Vous pouvez sérialiser des champs et des propriétés, quelle que soit l'accessibilité : privés, protégés, internes, internes protégés ou publics.

Par exemple, votre schéma spécifie un Customer avec une propriété ID, mais vous possédez déjà une application existante qui utilise un type nommé Person avec une propriété Name. Pour créer un type conforme au contrat, appliquez d'abord la classe DataContractAttribute à la classe. Appliquez ensuite la classe DataMemberAttribute à chaque champ ou propriété que vous souhaitez sérialiser.

Remarque

Vous pouvez appliquer la classe DataMemberAttribute aux membres privés et publics.

Le format final du code XML ne doit pas obligatoirement être le format texte. À la place, la classe DataContractSerializer écrit les données comme un jeu d'informations XML, qui vous permet d'écrire les données dans n'importe quel format reconnu par la classe XmlReader et XmlWriter. Il est recommandé d'utiliser les classes XmlDictionaryReader et XmlDictionaryWriter pour lire et écrire, car toutes deux sont optimisées pour l'utilisation de la classe DataContractSerializer.

Si vous créez une classe qui a des champs ou des propriétés qui doivent être renseignés avant la sérialisation ou la désérialisation, utilisez des attributs de rappel, comme décrit dans Rappels de sérialisation à tolérance de version.

Ajout à la collection des types connus

Lors de la sérialisation ou désérialisation d'un objet, il est nécessaire que le type soit « connu » de la classe DataContractSerializer. Commencez en créant une instance d’une classe qui implémente IEnumerable<T> (comme List<T>) et en ajoutant les types connus à la collection. Créez ensuite une instance de la classe DataContractSerializer à l'aide d'une des surcharges qui utilise l'interface IEnumerable<T> (par exemple, DataContractSerializer(Type, IEnumerable<Type>).

Remarque

Contrairement à d’autres types primitifs, la DateTimeOffset structure n’étant pas un type connu par défaut, elle doit être ajoutée manuellement à la liste des types connus (voir Types connus de contrat de données).

Compatibilité ascendante

La classe DataContractSerializer comprend les contrats de données conçus pour être compatibles avec de futures versions du contrat. Les types de cette sorte implémentent l'interface IExtensibleDataObject. L’interface présente la propriété ExtensionData qui retourne un objet ExtensionDataObject. Pour plus d’informations, consultez Contrats de données compatibles avec des versions ultérieures.

Exécution en situation de confiance partielle

Lorsque vous instanciez l'objet cible pendant la désérialisation, la classe DataContractSerializer n'appelle pas le constructeur de l'objet cible. Si vous créez un type [DataContract] accessible à partir d’une confiance partielle (c’est-à-dire qu’il est public et dans un assembly auquel l’attribut est appliqué) et que vous effectuez des actions liées à la AllowPartiallyTrustedCallers sécurité, vous devez savoir que le constructeur n’est pas appelé. En particulier, les techniques suivantes ne fonctionnent pas:

  • Si vous essayez de restreindre l’accès en confiance partielle en rendant le constructeur interne ou privé, ou en ajoutant un LinkDemand au constructeur, ni l’un ni l’autre n’ont d’effet pendant la désérialisation en confiance partielle.

  • Si vous codez la classe qui suppose que le constructeur a été exécuté, la classe peut se retrouver en état interne non valide qui est exploitable.

Constructeurs

DataContractSerializer(Type)

Initialise une nouvelle instance de la classe DataContractSerializer pour sérialiser ou désérialiser un objet du type spécifié.

DataContractSerializer(Type, DataContractSerializerSettings)

Initialise une nouvelle instance de la classe DataContractSerializer pour sérialiser ou désérialiser un objet avec le type et les paramètres spécifiés.

DataContractSerializer(Type, IEnumerable<Type>)

Initialise une nouvelle instance de la classe DataContractSerializer pour sérialiser ou désérialiser un objet du type spécifié, et une collection de types connus pouvant être présents dans le graphique d'objets.

DataContractSerializer(Type, IEnumerable<Type>, Int32, Boolean, Boolean, IDataContractSurrogate)

Initialise une nouvelle instance de la classe DataContractSerializer pour sérialiser ou désérialiser un objet du type spécifié. Cette méthode spécifie également une liste des types connus qui peuvent être présents dans le graphique d'objets, le nombre maximal d'éléments de graphique à sérialiser, les paramètres pour ignorer les données inattendues, s'il faut utiliser des constructions XML non standard pour conserver les données de référence d'objet dans le graphique, et un substitut pour la sérialisation personnalisée.

DataContractSerializer(Type, IEnumerable<Type>, Int32, Boolean, Boolean, IDataContractSurrogate, DataContractResolver)

Initialise une nouvelle instance de la classe DataContractSerializer pour sérialiser ou désérialiser un objet du type spécifié. Cette méthode spécifie également une liste des types connus qui peuvent être présents dans le graphique d'objets, le nombre maximal d'éléments de graphique à sérialiser, les paramètres pour ignorer des données inattendues, s'il faut utiliser des constructions XML non standard pour conserver les données de référence d'objet dans le graphique, un substitut pour la sérialisation personnalisée, ainsi qu'une autre approche pour mapper des déclarations xsi:type au moment de l'exécution.

DataContractSerializer(Type, String, String)

Initialise une nouvelle instance de la classe DataContractSerializer pour sérialiser ou désérialiser un objet du type spécifié à l'aide de l'élément racine et de l'espace de noms XML fournis.

DataContractSerializer(Type, String, String, IEnumerable<Type>)

Initialise une nouvelle instance de la classe DataContractSerializer pour sérialiser ou désérialiser un objet du type spécifié. Cette méthode spécifie également l'élément XML racine et l'espace de noms dans deux paramètres de chaîne ainsi qu'une liste des types connus pouvant être présents dans le graphique d'objets.

DataContractSerializer(Type, String, String, IEnumerable<Type>, Int32, Boolean, Boolean, IDataContractSurrogate)

Initialise une nouvelle instance de la classe DataContractSerializer pour sérialiser ou désérialiser un objet du type spécifié. Cette méthode spécifie également une liste des types connus qui peuvent être présents dans le graphique d'objets, le nombre maximal d'éléments de graphique à sérialiser, les paramètres pour ignorer des données inattendues, s'il faut utiliser des constructions XML non standard pour conserver les données de référence d'objet dans le graphique, un substitut pour la sérialisation personnalisée, ainsi que l'élément et l'espace de noms XML qui incluent le contenu.

DataContractSerializer(Type, String, String, IEnumerable<Type>, Int32, Boolean, Boolean, IDataContractSurrogate, DataContractResolver)

Initialise une nouvelle instance de la classe DataContractSerializer pour sérialiser ou désérialiser un objet du type spécifié. Cette méthode spécifie également une liste des types connus qui peuvent être présents dans le graphique d'objets, le nombre maximal d'éléments de graphique à sérialiser, les paramètres pour ignorer des données inattendues, s'il faut utiliser des constructions XML non standard pour conserver les données de référence d'objet dans le graphique, un substitut pour la sérialisation personnalisée, l'élément et l'espace de noms XML qui contient le contenu, ainsi qu'une autre approche pour mapper des déclarations xsi:type au moment de l'exécution.

DataContractSerializer(Type, XmlDictionaryString, XmlDictionaryString)

Initialise une nouvelle instance de la classe DataContractSerializer pour sérialiser ou désérialiser un objet du type spécifié à l'aide de l'élément racine et de l'espace de noms XML spécifiés dans les paramètres de type XmlDictionaryString.

DataContractSerializer(Type, XmlDictionaryString, XmlDictionaryString, IEnumerable<Type>)

Initialise une nouvelle instance de la classe DataContractSerializer pour sérialiser ou désérialiser un objet du type spécifié. Cette méthode spécifie également l'élément XML racine et l'espace de noms dans deux paramètres XmlDictionaryString ainsi qu'une liste de types connus pouvant être présents dans le graphique d'objets.

DataContractSerializer(Type, XmlDictionaryString, XmlDictionaryString, IEnumerable<Type>, Int32, Boolean, Boolean, IDataContractSurrogate)

Initialise une nouvelle instance de la classe DataContractSerializer pour sérialiser ou désérialiser un objet du type spécifié. Cette méthode spécifie également une liste des types connus qui peuvent être présents dans le graphique d'objets, le nombre maximal d'éléments de graphique à sérialiser, les paramètres pour ignorer les données inattendues, s'il faut utiliser des constructions XML non standard pour conserver les données de référence d'objet dans le graphique, un substitut pour la sérialisation personnalisée, et les paramètres XmlDictionaryString qui spécifient l'élément et l'espace de noms XML qui contiennent le contenu.

DataContractSerializer(Type, XmlDictionaryString, XmlDictionaryString, IEnumerable<Type>, Int32, Boolean, Boolean, IDataContractSurrogate, DataContractResolver)

Initialise une nouvelle instance de la classe DataContractSerializer pour sérialiser ou désérialiser un objet du type spécifié. Cette méthode spécifie également une liste des types connus qui peuvent être présents dans le graphique d'objets, le nombre maximal d'éléments de graphique à sérialiser, les paramètres pour ignorer des données inattendues, s'il faut utiliser des constructions XML non standard pour conserver les données de référence d'objet dans le graphique, un substitut pour la sérialisation personnalisée, les paramètres de XmlDictionaryString qui spécifient l'élément et l'espace de noms XML qui contient le contenu, ainsi qu'une autre approche pour mapper des déclarations xsi:type au moment de l'exécution.

Propriétés

DataContractResolver

Obtient le composant utilisé pour mapper dynamiquement les déclarations xsi:type aux types de contrat connus.

DataContractSurrogate

Obtient un type de substitut capable d’étendre le processus de sérialisation ou de désérialisation.

IgnoreExtensionDataObject

Obtient une valeur qui spécifie s'il faut ignorer les données fournies par une extension de la classe lors de la sérialisation ou la désérialisation de la classe.

KnownTypes

Obtient une collection des types pouvant être présents dans le graphique d'objets sérialisé à l'aide de cette instance de DataContractSerializer.

MaxItemsInObjectGraph

Obtient le nombre maximal d'éléments à sérialiser ou désérialiser dans un graphique d'objets.

PreserveObjectReferences

Obtient une valeur qui spécifie s'il faut utiliser des constructions XML non standard pour conserver des données de référence d'objet.

SerializeReadOnlyTypes

Obtient une valeur qui spécifie si les types en lecture seule sont sérialisés.

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
IsStartObject(XmlDictionaryReader)

Détermine si la classe XmlDictionaryReader est positionnée sur un objet pouvant être désérialisé.

IsStartObject(XmlReader)

Détermine si la classe XmlReader est positionnée sur un objet pouvant être désérialisé.

MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
ReadObject(Stream)

Lit le flux ou le document XML avec un Stream et retourne l'objet désérialisé.

(Hérité de XmlObjectSerializer)
ReadObject(XmlDictionaryReader)

Lit le document ou le flux XML avec un XmlDictionaryReader et retourne l'objet désérialisé.

(Hérité de XmlObjectSerializer)
ReadObject(XmlDictionaryReader, Boolean)

Lit le flux XML avec une classe XmlDictionaryReader et retourne l'objet désérialisé. Il spécifie également si un contrôle doit être effectué pour vérifier le nom de l'objet avant de lire sa valeur.

ReadObject(XmlDictionaryReader, Boolean, DataContractResolver)

Lit un document XML ou un flux de document et retourne l'objet désérialisé. La méthode contient un paramètre pour spécifier si le nom d'objet est vérifié et validé, et un programme de résolution pour le mappage de déclarations xsi:type au moment de l'exécution.

ReadObject(XmlReader)

Lit le flux XML avec une classe XmlReader et retourne l'objet désérialisé.

ReadObject(XmlReader, Boolean)

Lit le flux XML avec une classe XmlReader et retourne l'objet désérialisé. Il spécifie également si un contrôle doit être effectué pour vérifier le nom de l'objet avant de lire sa valeur.

ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)
WriteEndObject(XmlDictionaryWriter)

Écrit l'élément XML de fermeture à l'aide d'une classe XmlDictionaryWriter.

WriteEndObject(XmlWriter)

Écrit l'élément XML de fermeture à l'aide d'une classe XmlWriter.

WriteObject(Stream, Object)

Écrit le contenu complet (début, contenu et fin) de l'objet dans le flux ou le document XML avec le Stream spécifié.

(Hérité de XmlObjectSerializer)
WriteObject(XmlDictionaryWriter, Object)

Écrit le contenu complet (début, contenu et fin) de l'objet dans le flux ou le document XML avec le XmlDictionaryWriter spécifié.

(Hérité de XmlObjectSerializer)
WriteObject(XmlDictionaryWriter, Object, DataContractResolver)

Écrit toutes les données d’objet (élément XML de démarrage, contenu et élément englobant) dans un document ou un flux XML à l’aide du XmlDictionaryWriter spécifié. La méthode inclut un programme de résolution pour le mappage de déclarations xsi:type au moment de l'exécution.

WriteObject(XmlWriter, Object)

Écrit toutes les données d'objet (élément XML de début, de contenu et de fermeture) dans un document ou un flux XML avec une classe XmlWriter.

WriteObjectContent(XmlDictionaryWriter, Object)

Écrit le contenu XML à l'aide d'une classe XmlDictionaryWriter.

WriteObjectContent(XmlWriter, Object)

Écrit le contenu XML à l'aide d'une classe XmlWriter.

WriteStartObject(XmlDictionaryWriter, Object)

Écrit l'élément XML d'ouverture à l'aide d'une classe XmlDictionaryWriter.

WriteStartObject(XmlWriter, Object)

Écrit l'élément XML d'ouverture à l'aide d'une classe XmlWriter.

Méthodes d’extension

GetSerializationSurrogateProvider(DataContractSerializer)

Retourne le substitut de fournisseur de sérialisation pour ce sérialiseur.

SetSerializationSurrogateProvider(DataContractSerializer, ISerializationSurrogateProvider)

Spécifie un fournisseur de sérialisation de substitution pour ce DataContractSerializer.

S’applique à

Cohérence de thread

Les instances de cette classe sont thread-safe, sauf quand l’instance est utilisée avec une implémentation de ou IDataContractSurrogateDataContractResolver.

Voir aussi