KnownTypeAttribute Classe

Définition

Espace de noms:

System.Runtime.Serialization

Assemblys:

netstandard.dll, System.Runtime.Serialization.Primitives.dll

Source:

KnownTypeAttribute.cs

Spécifie les types qui doivent être reconnus par le DataContractSerializer lors de la sérialisation ou de la désérialisation d'un type donné.

C#

[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Struct, AllowMultiple=true, Inherited=true)]
public sealed class KnownTypeAttribute : Attribute

Héritage

Object

Attribute

KnownTypeAttribute

Attributs

AttributeUsageAttribute

Exemples

L'exemple suivant illustre un type nommé Person et un type nommé IDInformation qui doivent être reconnus lors de la sérialisation ou de la désérialisation du type Person.

C#

using System;
using System.Collections.Generic;
using System.Collections;
using System.Text;
using System.IO;
using System.Runtime.Serialization;

namespace KnownTypeAttributeExample
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Serialize("KnownTypeAttributeExample.xml");
                Deserialize("KnownTypeAttributeExample.xml");
                // Run this twice. The second time, comment out the
                // Serialize call and comment out the
                // KnownTypeAttribute on the Person class. The
                // deserialization will then fail.
            }
            catch (SerializationException exc)
            {
                Console.WriteLine("{0}: {1}", exc.Message,
                    exc.StackTrace);
            }
            finally
            {
                Console.WriteLine("Press Enter to exit...");
                Console.ReadLine();
            }
        }

        public static void Serialize(string path)
        {
            Person p = new Person();
            p.Miscellaneous.Add(DateTime.Now, "Hello");
            p.Miscellaneous.Add(DateTime.Now.AddSeconds(1), "World");
            IDInformation w = new IDInformation();
            w.ID = "1111 00000";
            p.Miscellaneous.Add(DateTime.Now.AddSeconds(2), w);
            DataContractSerializer ser =
                new DataContractSerializer(typeof(Person));
            FileStream fs = new FileStream(path, FileMode.Create);
            using (fs)
            {
                ser.WriteObject(fs, p);
            }
        }

        public static void Deserialize(string path)
        {
            DataContractSerializer ser =
                new DataContractSerializer(typeof(Person));
            FileStream fs = new FileStream(path, FileMode.Open);
            using (fs)
            {
                Person p2 = (Person)ser.ReadObject(fs);
                Console.WriteLine("Count {0}", p2.Miscellaneous.Count);
                foreach (DictionaryEntry de in p2.Miscellaneous)
                {
                    Console.WriteLine("Key {0} Value: {1}", de.Key,
                    de.Value);
                    if (de.Value.GetType() == typeof(IDInformation))
                    {
                        IDInformation www = (IDInformation)de.Value;
                        Console.WriteLine(
                        "\t Found ID Information. ID: {0} \n", www.ID);
                    }
                }
            }
        }

        // Apply the KnownTypeAttribute to the class that
        // includes a member that returns a Hashtable.
        [KnownType(typeof(IDInformation))]
        [DataContract]
        public class Person : IExtensibleDataObject
        {
            private ExtensionDataObject ExtensionDataObjectValue;

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

            private Hashtable MiscellaneousValue = new Hashtable();
            [DataMember]
            public Hashtable Miscellaneous
            {
                get { return MiscellaneousValue; }
                set { MiscellaneousValue = value; }
            }
        }

        [DataContract]
        public class IDInformation : IExtensibleDataObject
        {
            private ExtensionDataObject ExtensionDataValue;
            public ExtensionDataObject ExtensionData
            {
                get { return ExtensionDataValue; }
                set { ExtensionDataValue = value; }
            }

            [DataMember]
            public string ID;
        }
    }
}

Remarques

Appliquez l'attribut KnownTypeAttribute à un type pour indiquer au DataContractSerializer les types qui doivent être reconnus lors de la sérialisation ou de la désérialisation d'une instance du type auquel l'attribut est appliqué. Cet attribut pourrait également être reconnu par les d'autres sérialiseurs qui comprennent des contrats de données.

Note

Dans votre code, vous pouvez utiliser le mot KnownType à la place de KnownTypeAttribute qui est plus long.

Vous pouvez appliquer une seule instance KnownTypeAttribute avec le jeu de propriétés MethodName ou un ou plusieurs instances KnownTypeAttribute avec le jeu de propriétés Type.

Constructeurs

KnownTypeAttribute(String)	Initialise une nouvelle instance de la classe KnownTypeAttribute avec le nom d'une méthode qui retourne un IEnumerable des types connus.
KnownTypeAttribute(Type)	Initialise une nouvelle instance de la classe KnownTypeAttribute à l'aide du type spécifié.

Propriétés

MethodName	Obtient le nom d’une méthode qui retournera une liste des types qui doivent être reconnus lors de la sérialisation ou de la désérialisation.
Type	Obtient le type qui doit être reconnu lors de la sérialisation ou de la désérialisation par le DataContractSerializer.
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)

S’applique à

Voir aussi

• DataContractAttribute
• DataMemberAttribute
• DataContractSerializer
• Types connus de contrats de données