Cet article a fait l'objet d'une traduction manuelle. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. |
Traduction
Source
|
DataContractAttribute, classe
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.
Assembly : System.Runtime.Serialization (dans System.Runtime.Serialization.dll)
Le type DataContractAttribute expose les membres suivants.
| Nom | Description | |
|---|---|---|
|
DataContractAttribute | Initialise une nouvelle instance de la classe DataContractAttribute. |
| Nom | Description | |
|---|---|---|
|
IsReference | Obtient ou définit une valeur qui indique s'il faut conserver les données de référence d'objet. |
|
|
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 son implémentation dans une classe dérivée, obtient un identificateur unique pour Attribute. (Hérité de Attribute.) |
| Nom | Description | |
|---|---|---|
|
|
Equals | Infrastructure. Retourne une valeur indiquant si cette instance équivaut à un objet spécifié. (Hérité de Attribute.) |
|
Finalize | Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de netto***ge avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.) |
|
|
GetHashCode | Retourne le code de hachage pour 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 | 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 de l'objet Object actif. (Hérité de Object.) |
|
|
ToString | Retourne une chaîne qui représente l'objet actuel. (Hérité de Object.) |
| Nom | Description | |
|---|---|---|
|
_Attribute.GetIDsOfNames | Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch. (Hérité de Attribute.) |
|
|
_Attribute.GetTypeInfo | 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 | Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). (Hérité de Attribute.) |
|
|
_Attribute.Invoke | Fournit l'accès aux propriétés et aux méthodes exposées par un objet. (Hérité de Attribute.) |
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 par le biais de l'infrastructure , vous devez également appliquer DataContractAttribute à toutes les classes qui contiennent et manipulent des données envoyées dans les messages. Pour plus d'informations sur les contrats de données, consultez Using Data Contracts.
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 Using Data Contracts.
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 connu comme un 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.
Remarque
|
|---|
|
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 pourraient être utilisées dans le même but.) Pour créer un schéma XML à partir de votre application, utilisez Service Model Metadata Utility Tool (Svcutil.exe) avec l'option /dconly en ligne de commande. 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 avec un point de terminaison qui retourne un document WSDL (Web Services Description Language) pour générer automatiquement le code et la configuration afin de créer un client . 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 le DataContractAttribute à une classe, il utilise le nom de la classe en tant que nom local et l'espace de noms de la classe (précédé par "http://schemas.datacontract.org/2004/07/") comme URI de l'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.
|
Remarque
|
|---|
|
Dans du code, vous pouvez utiliser le mot DataContract au lieu de DataContractAttribute qui est plus long. |
Contrôle 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 Data Contract Versioning.
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(); } } }
Windows 7, Windows Vista SP1 ou ultérieur, Windows XP SP3, Windows Server 2008 (installation minimale non prise en charge), Windows Server 2008 R2 (installation minimale prise en charge avec SP1 ou version ultérieure), Windows Server 2003 SP2
Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.
