DataContractSerializer Třída

Definice

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

Dědičnost

Object

XmlObjectSerializer

DataContractSerializer

Příklady

Následující příklad kódu ukazuje typ pojmenovaný Person , který je serializován pomocí DataContractSerializer .The following example code shows a type named Person that is serialized by the DataContractSerializer. DataContractAttributeAtribut je použit pro třídu a DataMemberAttribute je použit pro členy k DataContractSerializer určení toho, co se má serializovat.The DataContractAttribute attribute is applied to the class, and the DataMemberAttribute is applied to members to instruct the DataContractSerializer what to serialize.

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 

Poznámky

Použijte DataContractSerializer třídu k serializaci a deserializaci instancí typu do datového proudu XML nebo dokumentu.Use the DataContractSerializer class to serialize and deserialize instances of a type into an XML stream or document. Můžete například vytvořit typ s názvem Person s vlastnostmi, které obsahují důležitá data, jako je například název a adresa.For example, you can create a type named Person with properties that contain essential data, such as a name and address. Pak můžete vytvořit a manipulovat s instancí Person třídy a zapsat všechny její hodnoty vlastností v dokumentu XML pro pozdější načtení nebo v datovém proudu XML pro okamžitou přepravu.You can then create and manipulate an instance of the Person class and write all of its property values in an XML document for later retrieval, or in an XML stream for immediate transport. Nejdůležitější, používá se DataContractSerializer k serializaci a deserializaci dat odesílaných ve zprávách Windows Communication Foundation (WCF).Most important, the DataContractSerializer is used to serialize and deserialize data sent in Windows Communication Foundation (WCF) messages. Použijte DataContractAttribute atribut na třídy a DataMemberAttribute atribut na členy třídy, chcete-li určit vlastnosti a pole, které jsou serializovány.Apply the DataContractAttribute attribute to classes, and the DataMemberAttribute attribute to class members to specify properties and fields that are serialized.

Seznam typů, které mohou být serializovány, naleznete v části typy podporované serializátorem kontraktu dat.For a list of types that can be serialized, see Types Supported by the Data Contract Serializer.

Chcete-li použít DataContractSerializer , nejprve vytvořte instanci třídy a objekt vhodný pro zápis nebo čtení formátu; například instance XmlDictionaryWriter .To use the DataContractSerializer, first create an instance of a class and an object appropriate to writing or reading the format; for example, an instance of the XmlDictionaryWriter. Pak zavolejte WriteObject metodu pro zachování dat.Then call the WriteObject method to persist the data. Chcete-li načíst data, vytvořte objekt vhodný pro čtení datového formátu (například XmlDictionaryReader pro dokument XML) a zavolejte ReadObject metodu.To retrieve data, create an object appropriate to reading the data format (such as an XmlDictionaryReader for an XML document) and call the ReadObject method.

Další informace o použití naleznete v DataContractSerializer tématu serializace a deserializace.For more information about using the DataContractSerializer, see Serialization and Deserialization.

Typ serializátoru kontraktu dat můžete nastavit pomocí elementu < DataContractSerializer > v konfiguračním souboru klientské aplikace.You can set the type of a data contract serializer using the <dataContractSerializer> element in a client application configuration file.

Příprava tříd pro serializaci nebo deserializaciPreparing Classes for Serialization or Deserialization

DataContractSerializerJe používán v kombinaci s DataContractAttribute DataMemberAttribute třídami a.The DataContractSerializer is used in combination with the DataContractAttribute and DataMemberAttribute classes. Pro přípravu třídy pro serializaci použijte DataContractAttribute pro třídu.To prepare a class for serialization, apply the DataContractAttribute to the class. Pro každého člena třídy, která vrací data, která chcete serializovat, použijte DataMemberAttribute .For each member of the class that returns data that you want to serialize, apply the DataMemberAttribute. Můžete serializovat pole a vlastnosti bez ohledu na přístupnost: privátní, chráněná, interní, chráněná interní nebo veřejná.You can serialize fields and properties, regardless of accessibility: private, protected, internal, protected internal, or public.

Například vaše schéma určuje Customer ID vlastnost s vlastností, ale již máte existující aplikaci, která používá typ Person s Name vlastností.For example, your schema specifies a Customer with an ID property, but you already have an existing application that uses a type named Person with a Name property. Chcete-li vytvořit typ, který odpovídá kontraktu, nejprve použijte DataContractAttribute pro třídu.To create a type that conforms to the contract, first apply the DataContractAttribute to the class. Pak použijte DataMemberAttribute pro každé pole nebo vlastnost, které chcete serializovat.Then apply the DataMemberAttribute to every field or property that you want to serialize.

Konečný formát XML nemusí být text.The final format of the XML need not be text. Místo toho DataContractSerializer zapisuje data jako XML XML, což umožňuje zapisovat data do libovolného formátu rozpoznávaného XmlReader a XmlWriter .Instead, the DataContractSerializer writes the data as an XML infoset, which allows you to write the data to any format recognized by the XmlReader and XmlWriter. Doporučuje se použít XmlDictionaryReader XmlDictionaryWriter třídy a ke čtení a zápisu, protože obě jsou optimalizované pro práci s DataContractSerializer .It is recommended that you use the XmlDictionaryReader and XmlDictionaryWriter classes to read and write, because both are optimized to work with the DataContractSerializer.

Pokud vytváříte třídu, která má pole nebo vlastnosti, které musí být vyplněny před serializací nebo deserializací, použijte atributy zpětného volání, jak je popsáno v části zpětné volání serializace odolné vůči verzi.If you are creating a class that has fields or properties that must be populated before the serialization or deserialization occurs, use callback attributes, as described in Version-Tolerant Serialization Callbacks.

Přidání do kolekce známých typůAdding to the Collection of Known Types

Při serializaci nebo deserializaci objektu je vyžadován typ "známo" na DataContractSerializer .When serializing or deserializing an object, it is required that the type is "known" to the DataContractSerializer. Začněte vytvořením instance třídy, která implementuje IEnumerable<T> (například List<T> ) a přidáním známých typů do kolekce.Begin by creating an instance of a class that implements IEnumerable<T> (such as List<T>) and adding the known types to the collection. Pak vytvořte instanci s DataContractSerializer jedním z přetížení, která přebírají IEnumerable<T> (například DataContractSerializer(Type, IEnumerable<Type>) .Then create an instance of the DataContractSerializer using one of the overloads that takes the IEnumerable<T> (for example, DataContractSerializer(Type, IEnumerable<Type>).

Dopředná kompatibilitaForward Compatibility

DataContractSerializerPochopení kontraktů dat, které byly navrženy tak, aby byly kompatibilní s budoucími verzemi smlouvy.The DataContractSerializer understands data contracts that have been designed to be compatible with future versions of the contract. Tyto typy implementují IExtensibleDataObject rozhraní.Such types implement the IExtensibleDataObject interface. Rozhraní obsahuje ExtensionData vlastnost, která vrací ExtensionDataObject objekt.The interface features the ExtensionData property that returns an ExtensionDataObject object. Další informace najdete v tématu kontrakty dat kompatibilní s dopředné.For more information, see Forward-Compatible Data Contracts.

Spouštění v částečném vztahu důvěryhodnostiRunning under Partial Trust

Při vytváření instance cílového objektu během deserializace DataContractSerializer nevolá konstruktor cílového objektu.When instantiating the target object during deserialization, the DataContractSerializer does not call the constructor of the target object. Pokud vytvoříte typ [DataContract] , který je přístupný z částečné důvěryhodnosti (to znamená, že je veřejný a v sestavení s AllowPartiallyTrustedCallers použitým atributem) a že provádí některé akce související se zabezpečením, je nutné si uvědomit, že konstruktor není volán.If you author a [DataContract] type that is accessible from partial trust (that is, it is public and in an assembly that has the AllowPartiallyTrustedCallers attribute applied) and that performs some security-related actions, you must be aware that the constructor is not called. Konkrétně následující techniky nefungují:In particular, the following techniques do not work:

• Pokud se pokusíte omezit přístup s částečným vztahem důvěryhodnosti vytvořením interního nebo privátního konstruktoru nebo přidáním LinkDemand do konstruktoru – žádná z těchto možností nemá žádný účinek během deserializace v rámci částečného vztahu důvěryhodnosti.If you try to restrict partial trust access by making the constructor internal or private, or by adding a LinkDemand to the constructor -- neither of these have any effect during deserialization under partial trust.

• Pokud kódujete třídu, která předpokládá, že konstruktor je spuštěn, třída se může dostat do neplatného vnitřního stavu, který lze zneužít.If you code the class that assumes the constructor has run, the class may get into an invalid internal state that is exploitable.

Konstruktory

Vlastnosti

Metody

Metody rozšíření

Platí pro

Bezpečný přístup z více vláken

Instance této třídy jsou vláknově bezpečné, s výjimkou případů, kdy je instance použita s implementací IDataContractSurrogate nebo DataContractResolver .Instances of this class are thread safe except when the instance is used with an implementation of the IDataContractSurrogate or DataContractResolver.

Viz také

• DataMemberAttribute
• DataContractAttribute
• IExtensibleDataObject
• ExtensionDataObject
• Použití kontraktů datUsing Data Contracts
• Serializace a deserializaceSerialization and Deserialization