Sdílet prostřednictvím

Serializace a deserializace

  • Článek

Windows Communication Foundation (WCF) obsahuje nový serializační modul , the DataContractSerializer. Překládá DataContractSerializer se mezi objekty rozhraní .NET Framework a XML v obou směrech. Toto téma vysvětluje, jak serializátor funguje.

Při serializaci objektů rozhraní .NET Framework serializátor rozumí řadě programovacích modelů serializace, včetně nového modelu kontraktu dat. Úplný seznam podporovaných typů naleznete v části Typy podporované serializátorem kontraktu dat. Úvod k datovým kontraktům najdete v tématu Použití kontraktů dat.

Při deserializaci XML serializátor používá XmlReader a XmlWriter třídy. Podporuje také XmlDictionaryReader a XmlDictionaryWriter třídy, které jí umožňují vytvářet optimalizované XML v některých případech, například při použití binárního formátu XML WCF.

WCF také obsahuje doprovodný serializátor , the NetDataContractSerializer. Pomocná rutina NetDataContractSerializer:

  • Není zabezpečený. Další informace naleznete v průvodci zabezpečením BinaryFormatter.
  • BinaryFormatter Podobá se serializátorům a SoapFormatter serializátorům, protože také generuje názvy typů rozhraní .NET Framework jako součást serializovaných dat.
  • Používá se, pokud jsou stejné typy sdíleny na serializaci a deserializace končí.

Obě DataContractSerializer a NetDataContractSerializer odvozeny od společné základní třídy , XmlObjectSerializer.

Upozorňující

Serializuje DataContractSerializer řetězce obsahující řídicí znaky s šestnáctkovou hodnotou nižší než 20 jako entity XML. To může způsobit problém s jiným klientem než WCF při odesílání těchto dat do služby WCF.

Vytvoření instance DataContractSerializer

Vytvoření instance objektu DataContractSerializer je důležitým krokem. Po konstrukci nemůžete změnit žádné nastavení.

Zadání kořenového typu

Kořenový typ je typ , jehož instance jsou serializovány nebo deserializovány. Má DataContractSerializer mnoho přetížení konstruktoru, ale minimálně musí být pomocí parametru type zadán kořenový typ.

Serializátor vytvořený pro určitý kořenový typ nelze použít k serializaci (nebo deserializaci) jiného typu, pokud typ není odvozen od kořenového typu. Následující příklad ukazuje dvě třídy.

[DataContract]
public class Person
{
    // Code not shown.
}

[DataContract]
public class PurchaseOrder
{
    // Code not shown.
}

<DataContract()> _
Public Class Person
    ' Code not shown.
End Class

<DataContract()> _
Public Class PurchaseOrder
    ' Code not shown.
End Class

Tento kód vytvoří instanci DataContractSerializer , kterou lze použít pouze k serializaci nebo deserializaci instancí Person třídy.

DataContractSerializer dcs = new DataContractSerializer(typeof(Person));
// This can now be used to serialize/deserialize Person but not PurchaseOrder.

Dim dcs As New DataContractSerializer(GetType(Person))
' This can now be used to serialize/deserialize Person but not PurchaseOrder.

Určení známých typů

Pokud se polymorfismus podílí na serializovaných typech, které ještě nejsou zpracovávány pomocí atributu KnownTypeAttribute nebo jiného mechanismu, musí být seznam možných typů předán serializátoru pomocí parametru knownTypes . Další informace o známýchtypech

Následující příklad ukazuje třídu , která LibraryPatronzahrnuje kolekci určitého typu, the LibraryItem. Druhá třída definuje LibraryItem typ. Třetí a čtyři třídy (Book a Newspaper) dědí z LibraryItem třídy.

[DataContract]
public class LibraryPatron
{
    [DataMember]
    public LibraryItem[] borrowedItems;
}
[DataContract]
public class LibraryItem
{
    // Code not shown.
}

[DataContract]
public class Book : LibraryItem
{
    // Code not shown.
}

[DataContract]
public class Newspaper : LibraryItem
{
    // Code not shown.
}

<DataContract()> _
Public Class LibraryPatron
    <DataMember()> _
    Public borrowedItems() As LibraryItem
End Class

<DataContract()> _
Public Class LibraryItem
    ' Code not shown.
End Class

<DataContract()> _
Public Class Book
    Inherits LibraryItem
    ' Code not shown.
End Class

<DataContract()> _
Public Class Newspaper
    Inherits LibraryItem
    ' Code not shown.
End Class

Následující kód vytvoří instanci serializátoru pomocí parametru knownTypes .

// Create a serializer for the inherited types using the knownType parameter.
Type[] knownTypes = new Type[] { typeof(Book), typeof(Newspaper) };
DataContractSerializer dcs =
new DataContractSerializer(typeof(LibraryPatron), knownTypes);
// All types are known after construction.

' Create a serializer for the inherited types using the knownType parameter.
Dim knownTypes() As Type = {GetType(Book), GetType(Newspaper)}
Dim dcs As New DataContractSerializer(GetType(LibraryPatron), knownTypes)
' All types are known after construction.

Zadání výchozího kořenového názvu a oboru názvů

Při serializaci objektu se obvykle určuje výchozí název a obor názvů vnějšího elementu XML podle názvu datového kontraktu a oboru názvů. Názvy všech vnitřních prvků jsou určeny z názvů členů dat a jejich obor názvů je obor názvů datového kontraktu. Následující příklad nastaví Name a Namespace hodnoty v konstruktorech DataContractAttribute a DataMemberAttribute tříd.

[DataContract(Name = "PersonContract", Namespace = "http://schemas.contoso.com")]
public class Person2
{
    [DataMember(Name = "AddressMember")]
    public Address theAddress;
}

[DataContract(Name = "AddressContract", Namespace = "http://schemas.contoso.com")]
public class Address
{
    [DataMember(Name = "StreetMember")]
    public string street;
}

<DataContract(Name:="PersonContract", [Namespace]:="http://schemas.contoso.com")> _
Public Class Person2
    <DataMember(Name:="AddressMember")> _
    Public theAddress As Address
End Class

<DataContract(Name:="AddressContract", [Namespace]:="http://schemas.contoso.com")> _
Public Class Address
    <DataMember(Name:="StreetMember")> _
    Public street As String
End Class

Serializace instance Person třídy vytvoří XML podobný následujícímu.

<PersonContract xmlns="http://schemas.contoso.com">  
  <AddressMember>  
    <StreetMember>123 Main Street</StreetMember>  
   </AddressMember>  
</PersonContract>

Výchozí název a obor názvů kořenového prvku však můžete přizpůsobit předáním hodnot rootName parametrů konstruktoruDataContractSerializer.rootNamespace Všimněte si, že rootNamespace nemá vliv na obor názvů obsažených prvků, které odpovídají datovým členům. Ovlivňuje pouze obor názvů vnějšího prvku.

Tyto hodnoty lze předat jako řetězce nebo instance XmlDictionaryString třídy, aby bylo možné jejich optimalizaci pomocí binárního formátu XML.

Nastavení maximální kvóty objektů

Některé DataContractSerializer přetížení konstruktoru maxItemsInObjectGraph mají parametr. Tento parametr určuje maximální počet objektů serializátor serializace nebo deserializes v jednom ReadObject volání metody. (Metoda vždy čte jeden kořenový objekt, ale tento objekt může mít jiné objekty ve svých datových členech. Tyto objekty mohou mít jiné objekty atd.) Výchozí hodnota je 65536. Všimněte si, že při serializaci nebo deserializaci polí se každá položka pole počítá jako samostatný objekt. Všimněte si také, že některé objekty můžou mít velkou reprezentaci paměti, a proto samotná kvóta nemusí být dostatečná, aby se zabránilo útoku na dostupnost služby. Další informace najdete v tématu Důležité informace o zabezpečení dat. Pokud potřebujete tuto kvótu zvýšit nad výchozí hodnotu, je důležité to udělat jak na straně odesílání (serializace), tak na straně příjmu (deserializace), protože platí pro čtení i zápis dat.

Doba odezvy

Kruhová cesta nastane, když je objekt deserializován a re serializován v jedné operaci. Proto jde z XML na instanci objektu a zpět do datového proudu XML.

Některá DataContractSerializer přetížení konstruktoru ignoreExtensionDataObject mají parametr, který je nastavený false ve výchozím nastavení. V tomto výchozím režimu je možné data odeslat na zpáteční cestu z novější verze kontraktu dat prostřednictvím starší verze a zpět na novější verzi bez ztráty, pokud kontrakt dat implementuje IExtensibleDataObject rozhraní. Předpokládejme například, že verze 1 datového kontraktu Person obsahuje Name členy a PhoneNumber datové členy a verze 2 přidá člena Nickname . Pokud IExtensibleDataObject je implementováno, při odesílání informací z verze 2 do verze 1 jsou Nickname data uložena a pak se znovu vygenerují při opětovném serializaci dat. Proto se při odezvě neztratí žádná data. Další informace najdete v tématu Kontrakty dat kompatibilní s předáváním a verzí kontraktů dat.

Aspekty platnosti zabezpečení a schématu při odezvě

Odezvy můžou mít vliv na zabezpečení. Příkladem může být deserializace a ukládání velkých objemů nadbytečných dat bezpečnostní riziko. Může se jednat o bezpečnostní obavy týkající se opětovného generování těchto dat, že neexistuje způsob, jak ověřit, zejména v případě, že se týkají digitálních podpisů. Například v předchozím scénáři by koncový bod verze 1 mohl podepisovat Nickname hodnotu, která obsahuje škodlivá data. A konečně může docházet k obavám ohledně platnosti schématu: Koncový bod může vždy generovat data, která striktně dodržuje jeho stavový kontrakt, a ne žádné dodatečné hodnoty. V předchozím příkladu kontrakt koncového bodu verze 1 říká, že generuje pouze Name a PhoneNumber, a pokud se používá ověření schématu, vygenerování dodatečné Nickname hodnoty způsobí selhání ověření.

Povolení a zakázání odezvy

Pokud chcete vypnout odezvy IExtensibleDataObject , neimplementujte rozhraní. Pokud nemáte žádnou kontrolu nad typy, nastavte ignoreExtensionDataObject parametr tak, aby true dosáhl stejného efektu.

Zachování grafu objektů

Serializátor obvykle nezajímá identitu objektu, jako v následujícím kódu.

[DataContract]
public class PurchaseOrder
{
    [DataMember]
    public Address billTo;
    [DataMember]
    public Address shipTo;
}

[DataContract]
public class Address
{
    [DataMember]
    public string street;
}

<DataContract()> _
Public Class PurchaseOrder

    <DataMember()> _
    Public billTo As Address

    <DataMember()> _
    Public shipTo As Address

End Class

<DataContract()> _
Public Class Address

    <DataMember()> _
    Public street As String

End Class

Následující kód vytvoří nákupní objednávku.

// Construct a purchase order:
Address adr = new Address();
adr.street = "123 Main St.";
PurchaseOrder po = new PurchaseOrder();
po.billTo = adr;
po.shipTo = adr;

' Construct a purchase order:
Dim adr As New Address()
adr.street = "123 Main St."
Dim po As New PurchaseOrder()
po.billTo = adr
po.shipTo = adr

Všimněte si, že billTo pole jsou shipTo nastavená na stejnou instanci objektu. Vygenerovaný KÓD XML však duplikuje informace duplikované a vypadá podobně jako následující XML.

<PurchaseOrder>  
  <billTo><street>123 Main St.</street></billTo>  
  <shipTo><street>123 Main St.</street></shipTo>  
</PurchaseOrder>

Tento přístup má však následující charakteristiky, které mohou být nežádoucí:

  • Výkon. Replikace dat je neefektivní.

  • Cyklické odkazy. Pokud se objekty odkazují na sebe, i přes jiné objekty, serializace replikací vede k nekonečné smyčce. (Serializátor vyvolá SerializationException chybu, pokud k tomu dojde.)

  • Sémantika. Někdy je důležité zachovat skutečnost, že dva odkazy jsou na stejný objekt, a ne na dva identické objekty.

Z těchto důvodů mají některá DataContractSerializer přetížení konstruktoru preserveObjectReferences parametr (výchozí hodnota je false). Pokud je tento parametr nastaven na true, speciální metoda kódování odkazy na objekty, která pouze WCF rozumí, je použita. Když je nastavená hodnota true, příklad kódu XML teď vypadá podobně jako následující.

<PurchaseOrder ser:id="1">  
  <billTo ser:id="2"><street ser:id="3">123 Main St.</street></billTo>  
  <shipTo ser:ref="2"/>  
</PurchaseOrder>

Obor názvů "ser" odkazuje na standardní serializační obor názvů, http://schemas.microsoft.com/2003/10/Serialization/. Každá část dat je serializována pouze jednou a zadanou číslem ID a následná použití vede k odkazu na již serializovaná data.

Důležité

Pokud jsou v kontraktu XMLElementdat přítomny atributy "id" i "ref", je atribut "ref" dodržen a atribut "id" bude ignorován.

Je důležité pochopit omezení tohoto režimu:

  • XML DataContractSerializer vytvoří se preserveObjectReferences sadou true není interoperabilní s žádnými dalšími technologiemi a lze k němu přistupovat pouze jinou DataContractSerializer instancí, také s nastavenou preserveObjectReferences na true.

  • Pro tuto funkci není podporována žádná metadata (schéma). Schéma, které je vytvořeno, je platné pouze pro případ, kdy preserveObjectReferences je nastavena na false.

  • Tato funkce může způsobit pomalejší proces serializace a deserializace. I když data nemusí být replikována, musí se v tomto režimu provádět další porovnání objektů.

Upozornění

preserveObjectReferences Pokud je režim povolený, je obzvláště důležité nastavit maxItemsInObjectGraph hodnotu na správnou kvótu. Vzhledem ke způsobu zpracování polí v tomto režimu je pro útočníka snadné vytvořit malou škodlivou zprávu, která vede k velkému využití paměti omezené pouze kvótou maxItemsInObjectGraph .

Určení náhradního kontraktu dat

Některé DataContractSerializer přetížení konstruktoru dataContractSurrogate mají parametr, který může být nastaven na null. V opačném případě ji můžete použít k určení náhradního kontraktu IDataContractSurrogate dat, což je typ, který implementuje rozhraní. Rozhraní pak můžete použít k přizpůsobení serializace a deserializace procesu. Další informace naleznete v tématu Náhradní smlouvy dat.

Serializace

Následující informace platí pro všechny třídy, které dědí z XmlObjectSerializertřídy , včetně a DataContractSerializerNetDataContractSerializer tříd.

Jednoduchá serializace

Nejzásadnější způsob serializace objektu je předat ho metodě WriteObject . Existují tři přetížení, jedna pro zápis do Stream, nebo XmlWriterXmlDictionaryWriter. Stream Při přetížení je výstup XML v kódování UTF-8. XmlDictionaryWriter Při přetížení serializátor optimalizuje svůj výstup pro binární XML.

Při použití WriteObject metody serializátor používá výchozí název a obor názvů pro element obálky a zapíše ho spolu s obsahem (viz předchozí část "Určení výchozího kořenového názvu a oboru názvů").

Následující příklad ukazuje psaní pomocí .XmlDictionaryWriter

Person p = new Person();
DataContractSerializer dcs =
    new DataContractSerializer(typeof(Person));
XmlDictionaryWriter xdw =
    XmlDictionaryWriter.CreateTextWriter(someStream,Encoding.UTF8 );
dcs.WriteObject(xdw, p);

Dim p As New Person()
Dim dcs As New DataContractSerializer(GetType(Person))
Dim xdw As XmlDictionaryWriter = _
    XmlDictionaryWriter.CreateTextWriter(someStream, Encoding.UTF8)
dcs.WriteObject(xdw, p)

Tím se vytvoří kód XML podobný následujícímu.

<Person>  
  <Name>Jay Hamlin</Name>  
  <Address>123 Main St.</Address>  
</Person>

Podrobná serializace

WriteStartObjectPoužití , WriteObjectContenta WriteEndObject metody k zápisu koncového elementu, zápis obsahu objektu a uzavření obálky elementu, v uvedeném pořadí.

Poznámka:

Tyto metody nepřetěžují Stream .

Tato podrobná serializace má dvě společná použití. Jedním z nich je vložit obsah, jako jsou atributy nebo komentáře mezi WriteStartObject a WriteObjectContent, jak je znázorněno v následujícím příkladu.

dcs.WriteStartObject(xdw, p);
xdw.WriteAttributeString("serializedBy", "myCode");
dcs.WriteObjectContent(xdw, p);
dcs.WriteEndObject(xdw);

dcs.WriteStartObject(xdw, p)
xdw.WriteAttributeString("serializedBy", "myCode")
dcs.WriteObjectContent(xdw, p)
dcs.WriteEndObject(xdw)

Tím se vytvoří kód XML podobný následujícímu.

<Person serializedBy="myCode">  
  <Name>Jay Hamlin</Name>  
  <Address>123 Main St.</Address>  
</Person>

Dalším běžným použitím je vyhnout se použití WriteStartObject a WriteEndObject zcela a psaní vlastního elementu obálky (nebo dokonce přeskočit psaní obálky úplně), jak je znázorněno v následujícím kódu.

xdw.WriteStartElement("MyCustomWrapper");
dcs.WriteObjectContent(xdw, p);
xdw.WriteEndElement();

xdw.WriteStartElement("MyCustomWrapper")
dcs.WriteObjectContent(xdw, p)
xdw.WriteEndElement()

Tím se vytvoří kód XML podobný následujícímu.

<MyCustomWrapper>  
  <Name>Jay Hamlin</Name>  
  <Address>123 Main St.</Address>  
</MyCustomWrapper>

Poznámka:

Při použití podrobné serializace může dojít k neplatnému schématu XML.

Rekonstrukci

Následující informace platí pro všechny třídy, které dědí z XmlObjectSerializertřídy , včetně a DataContractSerializerNetDataContractSerializer tříd.

Nejzásadnější způsob deserializace objektu je volání jednoho z ReadObject přetížení metody. Existují tři přetížení, jedna pro čtení s XmlDictionaryReader, nebo XmlReaderStream. Všimněte si, že Stream přetížení vytvoří textový text XmlDictionaryReader , který není chráněn žádnými kvótami, a měl by být použit pouze ke čtení důvěryhodných dat.

Všimněte si také, že objekt, který ReadObject metoda vrací, musí být přetypován na příslušný typ.

Následující kód vytvoří instanci DataContractSerializer a a XmlDictionaryReaderpak deserializuje Person instanci.

DataContractSerializer dcs = new DataContractSerializer(typeof(Person));
FileStream fs = new FileStream(path, FileMode.Open);
XmlDictionaryReader reader =
XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());

Person p = (Person)dcs.ReadObject(reader);

Dim dcs As New DataContractSerializer(GetType(Person))
Dim fs As New FileStream(path, FileMode.Open)
Dim reader As XmlDictionaryReader = _
   XmlDictionaryReader.CreateTextReader(fs, New XmlDictionaryReaderQuotas())

Dim p As Person = CType(dcs.ReadObject(reader), Person)

Před voláním ReadObject metody umístěte čtečku XML na element obálky nebo na uzel bez obsahu, který předchází elementu obálky. Můžete to provést voláním Read metody XmlReader nebo jeho odvození a testováním NodeType, jak je znázorněno v následujícím kódu.

DataContractSerializer ser = new DataContractSerializer(typeof(Person),
"Customer", @"http://www.contoso.com");
FileStream fs = new FileStream(path, FileMode.Open);
XmlDictionaryReader reader =
XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());
while (reader.Read())
{
    switch (reader.NodeType)
    {
        case XmlNodeType.Element:
            if (ser.IsStartObject(reader))
            {
                Console.WriteLine("Found the element");
                Person p = (Person)ser.ReadObject(reader);
                Console.WriteLine("{0} {1}    id:{2}",
                    p.Name , p.Address);
            }
            Console.WriteLine(reader.Name);
            break;
    }
}

Dim ser As New DataContractSerializer(GetType(Person), "Customer", "http://www.contoso.com")
Dim fs As New FileStream(path, FileMode.Open)
Dim reader As XmlDictionaryReader = XmlDictionaryReader.CreateTextReader(fs, New XmlDictionaryReaderQuotas())

While reader.Read()
    Select Case reader.NodeType
        Case XmlNodeType.Element
            If ser.IsStartObject(reader) Then
                Console.WriteLine("Found the element")
                Dim p As Person = CType(ser.ReadObject(reader), Person)
                Console.WriteLine("{0} {1}", _
                                   p.Name, p.Address)
            End If
            Console.WriteLine(reader.Name)
    End Select
End While

Všimněte si, že atributy na tomto elementu obálky lze před předáním čtenáře přečíst ReadObject.

Při použití jednoho z jednoduchých ReadObject přetížení hledá deserializátor výchozí název a obor názvů v elementu obálky (viz předchozí část "Určení výchozího kořenového názvu a oboru názvů") a vyvolá výjimku, pokud najde neznámý prvek. V předchozím příkladu se očekává element obálky <Person> . Metoda IsStartObject je volána k ověření, zda je čtenář umístěn na elementu, který je pojmenován podle očekávání.

Existuje způsob, jak zakázat tuto kontrolu názvu elementu obálky; některé přetížení ReadObject metody přebírají logický parametr verifyObjectName, který je nastaven ve true výchozím nastavení. Při nastavení na falsehodnotu je název a obor názvů elementu obálky ignorován. To je užitečné pro čtení XML, který byl napsán pomocí podrobného serializačního mechanismu popsaného dříve.

Použití NetDataContractSerializer

Hlavní rozdíl mezi a DataContractSerializer tím NetDataContractSerializer spočívá v tom, že DataContractSerializer používá názvy kontraktů dat, zatímco NetDataContractSerializer výstupy úplné sestavení rozhraní .NET Framework a názvy typů v serializovaném XML. To znamená, že mezi koncovými body serializace a deserializace musí být sdíleny přesně stejné typy. To znamená, že známý mechanismus typů není vyžadován s NetDataContractSerializer tím, že přesné typy, které mají být deserializovány, jsou vždy známé.

Může však dojít k několika problémům:

  • Zabezpečení. Načte se jakýkoli typ nalezený v deserializovaném souboru XML. To lze zneužít k vynucení načítání škodlivých typů. NetDataContractSerializer Použití s nedůvěryhodnými daty by mělo být provedeno pouze v případě, že se používá Serializace Binder (pomocí Binder vlastnosti nebo parametru konstruktoru). Pořadač umožňuje načtení pouze bezpečných typů. Mechanismus Binderu je shodný s mechanismem, který se používá v System.Runtime.Serialization oboru názvů.

  • Správa verzí. Použití úplných názvů typů a sestavení v jazyce XML výrazně omezuje způsob, jakým lze typy správě verzí. Nelze změnit následující: názvy typů, obory názvů, názvy sestavení a verze sestavení. Nastavení vlastnosti nebo parametru konstruktoru AssemblyFormat na Simple místo výchozí hodnoty Full umožňuje změny verze sestavení, ale ne pro obecné typy parametrů.

  • Interoperabilita: Vzhledem k tomu, že názvy typů a sestavení rozhraní .NET Framework jsou zahrnuty v jazyce XML, platformy jiné než rozhraní .NET Framework nemají přístup k výsledným datům.

  • Výkon. Zápis názvů typů a sestavení výrazně zvyšuje velikost výsledného XML.

Tento mechanismus je podobný binárnímu serializaci nebo serializaci PROTOKOLU SOAP používané vzdálené komunikace rozhraní .NET Framework (konkrétně, a BinaryFormatterSoapFormatter).

NetDataContractSerializer Použití je podobné použití , DataContractSerializers následujícími rozdíly:

  • Konstruktory nevyžadují, abyste zadali kořenový typ. Můžete serializovat libovolný typ se stejnou instancí NetDataContractSerializer.

  • Konstruktory nepřijímají seznam známých typů. Mechanismus známých typů není nutný, pokud jsou názvy typů serializovány do XML.

  • Konstruktory nepřijímají náhradní kontrakt dat. Místo toho přijímají parametr s ISurrogateSelector názvem surrogateSelector (který se mapuje na SurrogateSelector vlastnost). Jedná se o starší náhradní mechanismus.

  • Konstruktory přijímají parametr, assemblyFormatFormatterAssemblyStyle který se mapuje na AssemblyFormat vlastnost. Jak je popsáno dříve, lze ji použít k vylepšení možností správy verzí serializátoru. To je stejné jako FormatterAssemblyStyle mechanismus v binární nebo SOAP serializace.

  • Konstruktory přijímají StreamingContext parametr, který se mapuje context na Context vlastnost. Můžete ho použít k předání informací do typů serializovaných. Toto použití je stejné jako u mechanismu použitého StreamingContext v jiných System.Runtime.Serialization třídách.

  • Deserialize A Serialize metody jsou aliasy pro metody WriteObject a ReadObject metody. Existují k zajištění konzistentnějšího programovacího modelu s binárním serializací nebo serializací SOAP.

Další informace o těchto funkcích naleznete v tématu Binární serializace.

Formáty XML, které a které DataContractSerializer se používají, NetDataContractSerializer nejsou obvykle kompatibilní. To znamená, že pokus o serializaci s jedním z těchto serializátorů a deserializace s druhým není podporovaný scénář.

Všimněte si také, že NetDataContractSerializer výstupem není úplný typ rozhraní .NET Framework a název sestavení pro každý uzel v grafu objektu. Výstupem jsou informace pouze tam, kde jsou nejednoznačné. To znamená, že výstup na úrovni kořenového objektu a pro všechny polymorfní případy.

Viz také