Megosztás a következőn keresztül:

Szerializálás és deszerializálás

  • Cikk

A Windows Communication Foundation (WCF) tartalmaz egy új szerializációs motort, a DataContractSerializer. A DataContractSerializer fordítás .NET-keretrendszer objektumok és XML között, mindkét irányban. Ez a témakör a szerializáló működését ismerteti.

.NET-keretrendszer objektumok szerializálásakor a szerializáló számos szerializációs programozási modellt ismer, beleértve az új adatszerződési modellt is. A támogatott típusok teljes listáját az Adatszerződés szerializálója által támogatott típusok című témakörben találja. Az adatszerződések bemutatása: Adatszerződések használata.

Az XML deszerializálásakor a szerializáló az és XmlWriter az XmlReader osztályokat használja. Emellett támogatja azokat az XmlDictionaryReader osztályokat is XmlDictionaryWriter , amelyek lehetővé teszik, hogy optimalizált XML-t állíthasson elő bizonyos esetekben, például a WCF bináris XML-formátum használatakor.

WCF is tartalmaz egy társ szerializáló, a NetDataContractSerializer. Az NetDataContractSerializer:

Mindkettő DataContractSerializer és NetDataContractSerializer egy közös alaposztályból származik, XmlObjectSerializer.

Figyelmeztetés

A DataContractSerializer szerializálja a vezérlőkarakterekből álló sztringeket, amelyek hexadecimális értéke 20 alatt van XML-entitásként. Ez problémát okozhat egy nem WCF-ügyféllel, amikor ilyen adatokat küld egy WCF-szolgáltatásnak.

DataContractSerializer-példány létrehozása

A példány DataContractSerializer létrehozása fontos lépés. Az építés után a beállítások egyikét sem módosíthatja.

A gyökértípus megadása

A gyökér típusa az a típus, amelynek példányai szerializálva vagy deszerializálva vannak. A DataContractSerializer konstruktor túlterhelt, de legalább egy gyökértípust kell megadni a type paraméterrel.

Egy bizonyos gyökértípushoz létrehozott szerializáló nem használható egy másik típus szerializálására (vagy deszerializálására), kivéve, ha a típus a gyökértípusból származik. Az alábbi példa két osztályt mutat be.

[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

Ez a kód olyan példányt hoz létre, DataContractSerializer amely csak az osztály példányainak szerializálására vagy deszerializálására Person használható.

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.

Ismert típusok megadása

Ha a szerializálandó típusok polimorfizmussal vannak bevonva, amelyeket még nem kezelnek az KnownTypeAttribute attribútum vagy valamilyen más mechanizmus használatával, a lehetséges ismert típusok listáját át kell adni a szerializáló konstruktorának a knownTypes paraméter használatával. Az ismert típusokról további információt az Adatszerződés ismert típusai című témakörben talál.

Az alábbi példa egy osztályt mutat be, LibraryPatronamely egy adott típusú gyűjteményt tartalmaz, a .LibraryItem A második osztály határozza meg a típust LibraryItem . A harmadik és a négy osztály (Book és Newspaper) örököl az LibraryItem osztálytól.

[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

Az alábbi kód a paraméter használatával hozza létre a szerializáló egy példányát 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.

Az alapértelmezett gyökérnév és névtér megadása

Általában egy objektum szerializálása esetén a legkülső XML-elem alapértelmezett neve és névtere az adatszerződés neve és névtere alapján lesz meghatározva. Az összes belső elem nevét az adattagok neve határozza meg, a névtér pedig az adatszerződés névtere. Az alábbi példakészletek Name és Namespace értékek az és DataMemberAttribute osztályok DataContractAttribute konstruktoraiban szerepelnek.

[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

Az osztály egy példányának szerializálása az Person alábbihoz hasonló XML-t eredményez.

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

A gyökérelem alapértelmezett nevét és névterét azonban testre szabhatja úgy, hogy a konstruktornak átadja a paraméterek és rootNamespace a rootName paraméterek értékeitDataContractSerializer. Vegye figyelembe, hogy a rootNamespace névtér nem befolyásolja az adattagoknak megfelelő tartalmazott elemek névterét. Csak a legkülső elem névterére van hatással.

Ezek az értékek átadhatók az osztály sztringjeiként vagy példányaiként, hogy lehetővé tegyék XmlDictionaryString az optimalizálást a bináris XML-formátum használatával.

A Maximális objektumkvóta beállítása

Egyes DataContractSerializer konstruktor-túlterhelések paraméterrel maxItemsInObjectGraph rendelkeznek. Ez a paraméter határozza meg, hogy a szerializáló hány objektumot szerializál vagy deszerializál egyetlen ReadObject metódushívásban. (A metódus mindig beolvassa az egyik gyökérobjektumot, de előfordulhat, hogy az objektumnak más objektumai is vannak az adattagjaiban. Ezek az objektumok lehetnek más objektumok, és így tovább.) Az alapértelmezett érték 65536. Vegye figyelembe, hogy tömbök szerializálása vagy deszerializálása során minden tömbbejegyzés külön objektumként számít. Vegye figyelembe azt is, hogy egyes objektumok nagy memóriaképet tartalmazhatnak, ezért ez a kvóta önmagában nem elegendő a szolgáltatásmegtagadásos támadások megelőzéséhez. További információkért tekintse meg az adatok biztonsági szempontjait. Ha ezt a kvótát az alapértelmezett értéken túl kell növelnie, fontos, hogy a küldési (szerializálási) és a fogadási (deszerializálási) oldalon is ezt tegye, mert az adatok olvasása és írása során egyaránt érvényes.

Adatváltások

Körút akkor fordul elő, ha egy objektum deszerializálva és újra szerializálva van egy műveletben. Így az XML-ből egy objektumpéldányba kerül, majd vissza egy XML-adatfolyamba.

Egyes DataContractSerializer konstruktorok túlterhelésének van egy ignoreExtensionDataObject paramétere, amely alapértelmezés szerint be van állítva false . Ebben az alapértelmezett módban az adatok elküldhetők egy adatszerződés újabb verziójából egy régebbi verzióról, és vissza az újabb verzióra veszteség nélkül, feltéve, hogy az adatszerződés megvalósítja az IExtensibleDataObject interfészt. Tegyük fel például, hogy az Person adatszerződés 1. verziója tartalmazza az adattagokat és PhoneNumber az Name adattagokat, a 2- es verzió pedig hozzáad egy tagotNickname. Ha IExtensibleDataObject implementálva van, a 2. verzióról az 1. verzióra küldi az Nickname adatokat, az adatok tárolása, majd az adatok ismételt szerializálása után újra ki lesz bocsátva, ezért a körút során nem vesznek el adatok. További információ: Továbbítással kompatibilis adatszerződések és adatszerződések verziószámozása.

Biztonsági és séma-érvényességi problémák a kerek utakkal kapcsolatban

A kerek utak biztonsági következményekkel járhatnak. A nagy mennyiségű felesleges adat deszerializálása és tárolása például biztonsági kockázatot jelenthet. Előfordulhat, hogy biztonsági aggályok merülnek fel az adatok újbóli kibocsátásával kapcsolatban, amelyet nem lehet ellenőrizni, különösen akkor, ha digitális aláírások is szerepelnek benne. Az előző forgatókönyvben például az 1- es verziójú végpont rosszindulatú adatokat tartalmazó értéket ír alá Nickname . Végül előfordulhatnak séma-érvényességi problémák: előfordulhat, hogy egy végpont mindig olyan adatokat szeretne kibocsátani, amelyek szigorúan megfelelnek a megadott szerződésnek, és nem tartalmaznak további értékeket. Az előző példában az 1-es verziójú végpont szerződése azt mondja, hogy csak Name az bocsát ki, és PhoneNumberha sémaérvényesítést használ, a többletérték Nickname kibocsátása sikertelen érvényesítést okoz.

A kerek utak engedélyezése és letiltása

A körutazások kikapcsolásához ne implementálja a IExtensibleDataObject felületet. Ha nincs szabályozva a típusok felett, állítsa be a ignoreExtensionDataObject paramétert úgy, hogy true ugyanazt a hatást érje el.

Objektumdiagram megőrzése

A szerializálót általában nem érdekli az objektumdentitás, mint az alábbi kódban.

[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

Az alábbi kód létrehoz egy vásárlási rendelést.

// 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

Figyelje meg, hogy billTo a shipTo mezők ugyanarra az objektumpéldányra vannak beállítva. A létrehozott XML azonban duplikálja a duplikált információkat, és az alábbi XML-hez hasonlóan néz ki.

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

Ez a megközelítés azonban a következő jellemzőkkel rendelkezik, amelyek nemkívánatosak lehetnek:

  • Teljesítmény. Az adatok replikálása nem hatékony.

  • Körkörös hivatkozások. Ha az objektumok önmagukra hivatkoznak, még más objektumokon keresztül is, a replikációval történő szerializálás végtelen ciklust eredményez. (A szerializáló ad egy SerializationException , ha ez történik.)

  • Szemantika. Néha fontos megőrizni azt a tényt, hogy két hivatkozás ugyanarra az objektumra vonatkozik, nem pedig két azonos objektumra.

Ezen okok miatt egyes DataContractSerializer konstruktor-túlterhelések paraméterrel preserveObjectReferences rendelkeznek (az alapértelmezett érték).false Ha ezt a paramétert trueállítja be, a rendszer egy speciális metódust használ az objektumhivatkozások kódolására, amelyet csak a WCF ismer. Ha be van trueállítva, az XML-kód példája a következőhöz hasonló.

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

A "ser" névtér a szabványos szerializálási névtérre utal. http://schemas.microsoft.com/2003/10/Serialization/ Minden egyes adat csak egyszer szerializálódik, és azonosítószámot ad meg, és a későbbi felhasználások a már szerializált adatokra mutató hivatkozást eredményeznek.

Fontos

Ha az "id" és a "ref" attribútum is szerepel az adatszerződésben XMLElement, akkor a rendszer tiszteletben tartja a "ref" attribútumot, és figyelmen kívül hagyja az "id" attribútumot.

Fontos megérteni ennek a módnak a korlátait:

  • A készlettel előállított XML DataContractSerializer nem működik együtt más technológiákkal, és csak egy másik DataContractSerializer példány érheti el, szintén a következőre preserveObjectReferencestruevan állítva: .preserveObjectReferencestrue

  • A szolgáltatás nem támogatja a metaadatokat (séma). A létrehozott séma csak arra az esetre érvényes, ha preserveObjectReferences a beállítás értéke false.

  • Ez a funkció azt okozhatja, hogy a szerializálási és deszerializálási folyamat lassabban fut. Bár az adatokat nem kell replikálni, ebben a módban további objektum-összehasonlításokat kell végezni.

Figyelemfelhívás

Ha a preserveObjectReferences mód engedélyezve van, különösen fontos, hogy az értéket a maxItemsInObjectGraph megfelelő kvótára állítsa. Mivel a tömbök kezelése ebben a módban történik, a támadók könnyen hozhatnak létre egy kis kártékony üzenetet, amely nagy memóriahasználatot eredményez, amelyet csak a maxItemsInObjectGraph kvóta korlátoz.

Adatszerződés helyettesítő megadása

Egyes DataContractSerializer konstruktor-túlterhelések paraméterrel rendelkeznek dataContractSurrogate , amelyek beállíthatók a következőre null: . Ellenkező esetben adatszerződést adhat meg helyettesítőként, amely az interfészt megvalósító IDataContractSurrogate típus. Ezután a felülettel testre szabhatja a szerializálási és deszerializálási folyamatot. További információ: Adatszerződés-helyettesítők.

Szerializációs

Az alábbi információk minden olyan osztályra vonatkoznak, amely az XmlObjectSerializeradott osztálytól öröklődik, beleértve az osztályokat és NetDataContractSerializer az DataContractSerializer osztályokat is.

Egyszerű szerializálás

Az objektumok szerializálásának legalapvetőbb módja, ha átadja azt a WriteObject metódusnak. Három túlterhelés van, egy-egy írás egy Stream, egy XmlWritervagy egy XmlDictionaryWriter. Stream A túlterhelés miatt a kimenet XML az UTF-8 kódolásban. A túlterhelés miatt a XmlDictionaryWriter szerializáló a bináris XML-hez optimalizálja a kimenetét.

A metódus használatakor a WriteObject szerializáló a burkolóelem alapértelmezett nevét és névterét használja, és a tartalommal együtt írja ki (lásd az előző "Az alapértelmezett gyökérnév és névtér megadása" szakaszt).

Az alábbi példa bemutatja az írást egy 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)

Ez az alábbihoz hasonló XML-t hoz létre.

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

Részletes szerializálás

WriteStartObjectA záróelem írásához, az objektum tartalmának megírásához és a burkolóelem bezárásához használja a , WriteObjectContentés WriteEndObject a metódusokat.

Feljegyzés

Ezeknek a módszereknek nincsenek Stream túlterhelései.

Ennek a lépésenkénti szerializálásnak két gyakori felhasználási módja van. Az egyik az, hogy olyan tartalmakat szúr be, mint például az attribútumok vagy a megjegyzések WriteStartObjectWriteObjectContenta következő példában látható módon.

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)

Ez az alábbihoz hasonló XML-t hoz létre.

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

Egy másik gyakori felhasználási lehetőség a használat WriteStartObjectWriteEndObject és a teljes használat elkerülése, valamint a saját egyéni burkolóelem írása (vagy akár a burkoló teljes írásának kihagyása), ahogy az az alábbi kódban is látható.

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

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

Ez az alábbihoz hasonló XML-t hoz létre.

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

Feljegyzés

A lépésenkénti szerializálás séma érvénytelen XML-t eredményezhet.

Deszerializálás

Az alábbi információk minden olyan osztályra vonatkoznak, amely az XmlObjectSerializeradott osztálytól öröklődik, beleértve az osztályokat és NetDataContractSerializer az DataContractSerializer osztályokat is.

Az objektumok deszerializálásának legalapvetőbb módja az egyik metódus túlterhelésének ReadObject meghívása. Három túlterhelés van, egy-egy az olvasáshoz egy XmlDictionaryReader, egy XmlReadervagy egy Stream. Vegye figyelembe, hogy a Stream túlterhelés olyan szöveges szöveget XmlDictionaryReader hoz létre, amelyet semmilyen kvóta nem véd, és csak megbízható adatok olvasására használható.

Azt is vegye figyelembe, hogy a ReadObject metódus által visszaadott objektumot a megfelelő típusra kell leadni.

Az alábbi kód egy példányt DataContractSerializer és egy példányt XmlDictionaryReaderhoz létre, majd deszerializál egy példányt Person .

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)

A metódus meghívása ReadObject előtt helyezze az XML-olvasót a burkolóelemre vagy a burkolóelemet megelőző nem tartalomcsomópontra. Ezt úgy teheti meg, hogy meghívja a Read származtatás metódusát XmlReader , és teszteli a NodeTypekövetkező kódban látható módon.

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

Vegye figyelembe, hogy a burkolóelem attribútumait elolvashatja, mielőtt átadja az olvasónak ReadObject.

Az egyszerű ReadObject túlterhelések egyikének használatakor a deszerializáló megkeresi a burkolóelem alapértelmezett nevét és névterét (lásd az előző, "Az alapértelmezett gyökérnév és névtér megadása" című szakaszt), és kivételt jelez, ha ismeretlen elemet talál. Az előző példában a <Person> burkolóelem várható. A IsStartObject metódust annak ellenőrzésére hívjuk meg, hogy az olvasó a várt módon elnevezett elemen van-e elhelyezve.

A burkolóelemnév-ellenőrzés letiltására van mód; A ReadObject metódus egyes túlterhelései az alapértelmezés szerint beállított logikai paramétert verifyObjectNametrue használják. Ha be van falseállítva, a burkolóelem neve és névtere figyelmen kívül lesz hagyva. Ez a korábban ismertetett lépésenkénti szerializálási mechanizmussal írt XML olvasásához hasznos.

A NetDataContractSerializer használata

Az és az DataContractSerializer elsődleges különbség azNetDataContractSerializer, hogy az DataContractSerializer adatszerződések neveit használja, míg a NetDataContractSerializer kimenetek teljes .NET-keretrendszer szerelvényt és típusneveket a szerializált XML-ben. Ez azt jelenti, hogy pontosan ugyanazokat a típusokat kell megosztani a szerializálási és a deszerializálási végpontok között. Ez azt jelenti, hogy az ismert típusok mechanizmusára nincs szükség, NetDataContractSerializer mivel a deszerializálandó pontos típusok mindig ismertek.

Azonban számos probléma fordulhat elő:

  • Biztonság. A deszerializálandó XML-fájlban található bármely típus betöltődik. Ez kihasználható a rosszindulatú típusok betöltésének kényszerítéséhez. NetDataContractSerializer A nem megbízható adatok használata csak szerializálási kötés használata esetén végezhető el (a tulajdonság vagy a Binder konstruktor paraméter használatával). A kötőanyag csak biztonságos típusok betöltését teszi lehetővé. A Binder mechanizmus megegyezik a névtérben System.Runtime.Serialization használt típusokkal.

  • Verziószámozás. Ha teljes típus- és szerelvényneveket használ az XML-ben, az jelentősen korlátozza a típusok verziószámba vételét. A következő nem módosítható: típusnevek, névterek, szerelvénynevek és szerelvényverziók. A tulajdonság vagy a AssemblyFormat konstruktor paraméter Simple beállítása az alapértelmezett érték helyett lehetővé teszi a szerelvény verzióváltozásait Full , az általános paramétertípusok esetében azonban nem.

  • Együttműködési lehetőség. Mivel .NET-keretrendszer típus- és szerelvénynevek szerepelnek az XML-ben, a .NET-keretrendszer kívüli platformok nem férhetnek hozzá az eredményként kapott adatokhoz.

  • Teljesítmény. A típus- és szerelvénynevek írása jelentősen növeli az eredményként kapott XML méretét.

Ez a mechanizmus hasonló a .NET-keretrendszer újraegyesítés által használt bináris vagy SOAP szerializáláshoz (pontosabban az BinaryFormatter és a SoapFormatter).

NetDataContractSerializer A használata hasonló a DataContractSerializerhasználatához, a következő különbségekkel:

  • A konstruktorok nem követelik meg, hogy gyökértípust adjon meg. Bármilyen típust szerializálhat ugyanazzal a példánnyal NetDataContractSerializer.

  • A konstruktorok nem fogadják el az ismert típusok listáját. Az ismert típusok mechanizmusa szükségtelen, ha a típusnevek szerializálva vannak az XML-ben.

  • A konstruktorok nem fogadnak el helyettesítő adatszerződést. Ehelyett elfogadnak egy ISurrogateSelector úgynevezett surrogateSelector paramétert (amely leképezi a SurrogateSelector tulajdonságot). Ez egy régi helyettesítő mechanizmus.

  • A konstruktorok elfogadják a FormatterAssemblyStyle tulajdonsághoz AssemblyFormat leképező paramétertassemblyFormat. Ahogy korábban már említettem, ez a szerializáló verziószámozási képességeinek javítására használható. Ez megegyezik a bináris vagy SOAP FormatterAssemblyStyle szerializálási mechanizmussal.

  • A konstruktorok elfogadják a StreamingContext tulajdonsághoz Context leképező paramétertcontext. Ezzel adatokat továbbíthat szerializált típusokba. Ez a használat megegyezik a StreamingContext más System.Runtime.Serialization osztályokban használt mechanizmus használatával.

  • A Serialize metódusok és Deserialize a WriteObjectReadObject metódusok aliasai. Ezek azért léteznek, hogy konzisztensebb programozási modellt biztosítsanak bináris vagy SOAP szerializálással.

További információ ezekről a funkciókról: Bináris szerializálás.

Azok az XML-formátumok, amelyek használata NetDataContractSerializerDataContractSerializer általában nem kompatibilis. Ez azt jelzi, hogy az egyik szerializálóval való szerializálás és a másikkal való deszerializálás nem támogatott forgatókönyv.

Azt is vegye figyelembe, hogy az NetDataContractSerializer objektumgráfban nem adja ki a teljes .NET-keretrendszer típust és szerelvénynevet az egyes csomópontokhoz. Ezt az információt csak akkor adja ki, ha az nem egyértelmű. Ez azt jelzi, hogy a kimenet a gyökérobjektum szintjén és bármilyen polimorfikus esetben jelenik meg.

Lásd még