DataContractAttribute Classe

Définition

Spécifie que le type définit ou implémente un contrat de données et qu'il est sérialisable par un sérialiseur, tel que le DataContractSerializer. Pour rendre un type sérialisable, les auteurs de types doivent définir un contrat de données pour ce type.

public ref class DataContractAttribute sealed : Attribute
[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Enum | System.AttributeTargets.Struct, AllowMultiple=false, Inherited=false)]
public sealed class DataContractAttribute : Attribute
[<System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Enum | System.AttributeTargets.Struct, AllowMultiple=false, Inherited=false)>]
type DataContractAttribute = class
    inherit Attribute
Public NotInheritable Class DataContractAttribute
Inherits Attribute
Héritage
DataContractAttribute
Attributs

Exemples

L'exemple suivant sérialise et désérialise une classe nommée Person à laquelle le DataContractAttribute a été appliqué. Notez que les propriétés Namespace et Name ont des valeurs qui substituent les paramètres par défaut.

namespace DataContractAttributeExample
{
    // Set the Name and Namespace properties to new values.
    [DataContract(Name = "Customer", Namespace = "http://www.contoso.com")]
    class Person : IExtensibleDataObject
    {
        // To implement the IExtensibleDataObject interface, you must also
        // implement the ExtensionData property.
        private ExtensionDataObject extensionDataObjectValue;
        public ExtensionDataObject ExtensionData
        {
            get
            {
                return extensionDataObjectValue;
            }
            set
            {
                extensionDataObjectValue = value;
            }
        }

        [DataMember(Name = "CustName")]
        internal string Name;

        [DataMember(Name = "CustID")]
        internal int ID;

        public Person(string newName, int newID)
        {
            Name = newName;
            ID = newID;
        }
    }

    class Test
    {
        public static void Main()
        {
            try
            {
                WriteObject("DataContractExample.xml");
                ReadObject("DataContractExample.xml");
                Console.WriteLine("Press Enter to end");
                Console.ReadLine();
            }
            catch (SerializationException se)
            {
                Console.WriteLine
                ("The serialization operation failed. Reason: {0}",
                  se.Message);
                Console.WriteLine(se.Data);
                Console.ReadLine();
            }
        }

        public static void WriteObject(string path)
        {
            // Create a new instance of the Person class and
            // serialize it to an XML file.
            Person p1 = new Person("Mary", 1);
            // Create a new instance of a StreamWriter
            // to read and write the data.
            FileStream fs = new FileStream(path,
            FileMode.Create);
            XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(fs);
            DataContractSerializer ser =
                new DataContractSerializer(typeof(Person));
            ser.WriteObject(writer, p1);
            Console.WriteLine("Finished writing object.");
            writer.Close();
            fs.Close();
        }
        public static void ReadObject(string path)
        {
            // Deserialize an instance of the Person class
            // from an XML file. First create an instance of the
            // XmlDictionaryReader.
            FileStream fs = new FileStream(path, FileMode.OpenOrCreate);
            XmlDictionaryReader reader =
                XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());

            // Create the DataContractSerializer instance.
            DataContractSerializer ser =
                new DataContractSerializer(typeof(Person));

            // Deserialize the data and read it from the instance.
            Person newPerson = (Person)ser.ReadObject(reader);
            Console.WriteLine("Reading this object:");
            Console.WriteLine(String.Format("{0}, ID: {1}",
            newPerson.Name, newPerson.ID));
            fs.Close();
        }
    }
}
Namespace DataContractAttributeExample
    ' Set the Name and Namespace properties to new values.
    <DataContract(Name := "Customer", [Namespace] := "http://www.contoso.com")>  _
    Class Person
        Implements IExtensibleDataObject
        ' To implement the IExtensibleDataObject interface, you must also
        ' implement the ExtensionData property.
        Private extensionDataObjectValue As ExtensionDataObject 
        
        Public Property ExtensionData() As ExtensionDataObject _
          Implements IExtensibleDataObject.ExtensionData
            Get
                Return extensionDataObjectValue
            End Get
            Set
                extensionDataObjectValue = value
            End Set
        End Property
        
        <DataMember(Name := "CustName")>  _
        Friend Name As String
        
        <DataMember(Name := "CustID")>  _
        Friend ID As Integer
        
        
        Public Sub New(ByVal newName As String, ByVal newID As Integer) 
            Name = newName
            ID = newID
        
        End Sub 
    End Class 
    
    
    Class Test
        
        Public Shared Sub Main() 
            Try
                WriteObject("DataContractExample.xml")
                ReadObject("DataContractExample.xml")
                Console.WriteLine("Press Enter to end")
                Console.ReadLine()
            Catch se As SerializationException
                Console.WriteLine("The serialization operation failed. Reason: {0}", _
                   se.Message)
                Console.WriteLine(se.Data)
                Console.ReadLine()
            End Try
        
        End Sub 
        
        
        Public Shared Sub WriteObject(ByVal path As String) 
            ' Create a new instance of the Person class and 
            ' serialize it to an XML file.
            Dim p1 As New Person("Mary", 1)
            ' Create a new instance of a StreamWriter
            ' to read and write the data.
            Dim fs As New FileStream(path, FileMode.Create)
            Dim writer As XmlDictionaryWriter = XmlDictionaryWriter.CreateTextWriter(fs)
            Dim ser As New DataContractSerializer(GetType(Person))
            ser.WriteObject(writer, p1)
            Console.WriteLine("Finished writing object.")
            writer.Close()
            fs.Close()
        
        End Sub 
        
        Public Shared Sub ReadObject(ByVal path As String) 
            ' Deserialize an instance of the Person class 
            ' from an XML file. First create an instance of the 
            ' XmlDictionaryReader.
            Dim fs As New FileStream(path, FileMode.OpenOrCreate)
            Dim reader As XmlDictionaryReader = XmlDictionaryReader. _
              CreateTextReader(fs, New XmlDictionaryReaderQuotas())
            
            ' Create the DataContractSerializer instance.
            Dim ser As New DataContractSerializer(GetType(Person))
            
            ' Deserialize the data and read it from the instance.
            Dim newPerson As Person = CType(ser.ReadObject(reader), Person)
            Console.WriteLine("Reading this object:")
            Console.WriteLine(String.Format("{0}, ID: {1}", newPerson.Name, newPerson.ID))
            fs.Close()
        
        End Sub 
    End Class 
End Namespace

Remarques

Appliquez l'attribut DataContractAttribute aux types (classes, structures ou énumérations) qui sont utilisés dans les opérations de sérialisation et de désérialisation par le DataContractSerializer. Si vous envoyez ou recevez des messages à l’aide de l’infrastructure Windows Communication Foundation (WCF), vous devez également appliquer les DataContractAttribute classes qui contiennent et manipulent les données envoyées dans les messages. Pour plus d’informations sur les contrats de données, consultez Utilisation de contrats de données.

Vous devez également appliquer les DataMemberAttribute à tout champ, propriété ou événement qui contiennent des valeurs que vous voulez sérialiser. En appliquant le DataContractAttribute, vous permettez explicitement au DataContractSerializer de sérialiser et de désérialiser les données.

Attention

Vous pouvez appliquer le DataMemberAttribute aux champs privés. Soyez conscient que les données retournées par le champ (même s'il est privé) sont sérialisées et désérialisées, et que, par conséquent, elles peuvent être affichées ou interceptées par un utilisateur ou un processus malveillant.

Pour plus d’informations sur les contrats de données, consultez les rubriques répertoriées dans Utilisation des contrats de données.

Contrats de données

Un contrat de données est une description abstraite d’un ensemble de champs avec un nom et un type de données pour chaque champ. Le contrat de données existe en dehors de toute implémentation unique pour permettre aux services sur différentes plates-formes d'interopérer. Tant que les données passées entre les services se conforment au même contrat, tous les services peuvent traiter les données. Ce traitement est également appelé système faiblement couplé. Un contrat de données est également semblable à une interface dans le sens où le contrat spécifie comment les données doivent être fournies afin qu'elles puissent être traitées par une application. Par exemple, le contrat de données peut demander un type de données nommé "Person" qui comporte deux champs de texte nommés, "FirstName" et "LastName". Pour créer un contrat de données, appliquez simplement DataContractAttribute à la classe et DataMemberAttribute aux champs ou aux propriétés qui doivent être sérialisés. Lorsqu'elles sont sérialisées, les données se conforment au contrat de données qui est implicitement intégré au type.

Notes

Un contrat de données diffère considérablement d'une interface réelle dans son comportement d'héritage. Les interfaces sont héritées par les types dérivés. Lorsque vous appliquez le DataContractAttribute à une classe de base, les types dérivés n'héritent pas de l'attribut ou du comportement. Toutefois, si un type dérivé comporte un contrat de données, les membres de données de la classe de base sont alors sérialisés. Toutefois, vous devez appliquer le DataMemberAttribute aux nouveaux membres dans une classe dérivée pour les rendre sérialisables.

Documents de schéma XML et outil SvcUtil

Si vous échangez des données avec des services, vous devez décrire le contrat de données. Pour la version actuelle du DataContractSerializer, un schéma XML peut être utilisé pour définir des contrats de données. (D’autres formes de métadonnées/description peuvent être utilisées à la même fin.) Pour créer un schéma XML à partir de votre application, utilisez l’outil Utilitaire de métadonnées ServiceModel (Svcutil.exe) avec l’option de ligne de commande /dconly . Lorsque l'entrée de l'outil est un assembly, l'outil génère par défaut un jeu de schémas XML qui définissent tous les types de contrats de données trouvés dans cet assembly. À l'inverse, vous pouvez également utiliser l'outil Svcutil.exe pour créer des définitions de classe Visual Basic ou C# qui se conforment aux spécifications des schémas XML utilisant des constructions que les contrats de données peuvent exprimer. Dans ce cas, l’option de ligne de commande /dconly n’est pas requise.

Si l'entrée de l'outil Svcutil.exe est un schéma XML, l'outil crée par défaut un ensemble de classes. Si vous examinez ces classes, vous pouvez constater que le DataContractAttribute a été appliqué. Vous pouvez utiliser ces classes afin de créer une application pour traiter des données qui doivent être échangées avec d'autres services.

Vous pouvez également exécuter l’outil sur un point de terminaison qui retourne un document WSDL (Web Services Description Language) pour générer automatiquement le code et la configuration pour créer un client Windows Communication Foundation (WCF). Le code généré inclut des types qui sont marqués avec le DataContractAttribute.

Réutilisation des types existants

Un contrat de données comporte deux spécifications de base : un nom stable et une liste de membres. Le nom stable est composé de l'URI (Uniform Resource Identifier) de l'espace de noms et du nom local du contrat. Par défaut, lorsque vous appliquez la DataContractAttribute classe à une classe, elle utilise le nom de classe comme nom local et l’espace de noms de la classe (précédé de "http://schemas.datacontract.org/2004/07/") comme URI d’espace de noms. Vous pouvez substituer les valeurs par défaut en définissant les propriétés Name et Namespace. Vous pouvez également modifier l'espace de noms en appliquant le ContractNamespaceAttribute à l'espace de noms. Utilisez cette fonction lorsque vous avez un type existant qui traite les données exactement comme vous l'avez demandé mais qui contient un espace de noms et un nom de classe différents dans le contrat de données. En substituant les valeurs par défaut, vous pouvez réutiliser votre type existant et conformer les données sérialisées au contrat de données.

Notes

Dans du code, vous pouvez utiliser le mot DataContract au lieu de DataContractAttribute qui est plus long.

Gestion de version

Un contrat de données accepte également des versions ultérieures. Autrement dit, lorsqu'une version ultérieure du contrat inclut des données supplémentaires, ces données sont stockées et retournées intactes à un expéditeur. Pour cela, implémentez l'interface IExtensibleDataObject.

Pour plus d’informations sur le contrôle de version, consultez Gestion des versions de contrat de données.

Constructeurs

DataContractAttribute()

Initialise une nouvelle instance de la classe DataContractAttribute.

Propriétés

IsNameSetExplicitly

Obtient l’information indiquant si Name a été défini explicitement.

IsNamespaceSetExplicitly

Obtient l’information indiquant si Namespace a été défini explicitement.

IsReference

Obtient ou définit une valeur qui indique s'il faut conserver les données de référence d'objet.

IsReferenceSetExplicitly

Obtient l’information indiquant si IsReference a été défini explicitement.

Name

Obtient ou définit le nom du contrat de données pour le type.

Namespace

Obtient ou définit l'espace de noms du contrat de données pour le type.

TypeId

Lors de l'implémentation dans une classe dérivée, obtient un identificateur unique pour l'objet Attribute.

(Hérité de Attribute)

Méthodes

Equals(Object)

Retourne une valeur qui indique si cette instance est égale à un objet spécifié.

(Hérité de Attribute)
GetHashCode()

Retourne le code de hachage de cette instance.

(Hérité de Attribute)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
IsDefaultAttribute()

En cas de substitution dans une classe dérivée, indique si la valeur de cette instance est la valeur par défaut pour la classe dérivée.

(Hérité de Attribute)
Match(Object)

En cas de substitution dans une classe dérivée, retourne une valeur indiquant si cette instance équivaut à un objet spécifié.

(Hérité de Attribute)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
ToString()

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

(Hérité de Object)

Implémentations d’interfaces explicites

_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.

(Hérité de Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Récupère les informations de type pour un objet, qui peuvent être utilisées pour obtenir les informations de type d'une interface.

(Hérité de Attribute)
_Attribute.GetTypeInfoCount(UInt32)

Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).

(Hérité de Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fournit l'accès aux propriétés et aux méthodes exposées par un objet.

(Hérité de Attribute)

S’applique à

Voir aussi