De xmlSerializer-klasse gebruiken

Windows Communication Foundation (WCF) kan twee verschillende serialisatietechnologieën gebruiken om de gegevens in uw toepassing om te zetten in XML die wordt verzonden tussen clients en services: DataContractSerializer en XmlSerializer.

DataContractSerializer

WCF gebruikt standaard de DataContractSerializer klasse om gegevenstypen te serialiseren. Deze serializer ondersteunt de volgende typen:

• Primitieve typen (bijvoorbeeld gehele getallen, tekenreeksen en bytematrices), evenals enkele speciale typen, zoals XmlElement en DateTime, die worden behandeld als primitieven.

• Gegevenscontracttypen (typen die zijn gemarkeerd met het DataContractAttribute kenmerk).

• Typen die zijn gemarkeerd met het SerializableAttribute kenmerk, waaronder typen die de ISerializable interface implementeren.

• Typen die de IXmlSerializable interface implementeren.

• Veel voorkomende verzamelingstypen, waaronder veel generieke verzamelingstypen.

Veel .NET Framework-typen vallen in de laatste twee categorieën en zijn dus serialiseerbaar. Matrices van serialiseerbare typen kunnen ook serialiseerbaar zijn. Voor een volledige lijst, zie Specificatie van gegevensoverdracht in servicecontracten.

De DataContractSerializer, samen met gegevenscontracttypen, is de aanbevolen manier om nieuwe WCF-services te schrijven. Zie Gegevenscontracten gebruiken voor meer informatie.

XmlSerializer

WCF ondersteunt ook de XmlSerializer klasse. De XmlSerializer klasse is niet uniek voor WCF. Het is dezelfde serialisatie-engine die ASP.NET webservices gebruiken. De XmlSerializer klasse ondersteunt een veel smallere set typen dan de DataContractSerializer klasse, maar biedt veel meer controle over de resulterende XML en ondersteunt veel meer van de XSD-standaard (XML Schema Definition Language). Er zijn ook geen declaratieve kenmerken voor de serialiseerbare typen vereist. Zie het onderwerp XML-serialisatie in de .NET Framework-documentatie voor meer informatie. De XmlSerializer klasse biedt geen ondersteuning voor gegevenscontracttypen.

Wanneer u Svcutil.exe of de functie Serviceverwijzing toevoegen in Visual Studio gebruikt om clientcode te genereren voor een service van derden of om toegang te krijgen tot een schema van derden, wordt automatisch een geschikte serializer voor u geselecteerd. Als het schema niet compatibel is met het DataContractSerializerschema, is de XmlSerializer optie geselecteerd.

Overschakelen naar de XmlSerializer

Soms moet u mogelijk handmatig overschakelen naar de XmlSerializer. Dit gebeurt bijvoorbeeld in de volgende gevallen:

• Wanneer u een toepassing migreert van ASP.NET-webservices naar WCF, wilt u mogelijk bestaande, XmlSerializercompatibele typen opnieuw gebruiken in plaats van nieuwe typen gegevenscontract te maken.

• Wanneer nauwkeurige controle over de XML die wordt weergegeven in berichten belangrijk is, maar een WSDL-document (Web Services Description Language) niet beschikbaar is, bijvoorbeeld wanneer u een service maakt met typen die moeten voldoen aan een bepaald gestandaardiseerde, gepubliceerde schema dat niet compatibel is met de DataContractSerializer.

• Wanneer u services maakt die voldoen aan de verouderde SOAP-coderingsstandaard.

In deze en andere gevallen kunt u handmatig overschakelen naar de XmlSerializer klasse door het XmlSerializerFormatAttribute kenmerk toe te passen op uw service, zoals wordt weergegeven in de volgende code.

[ServiceContract]
[XmlSerializerFormat]
public class BankingService
{
[OperationContract]
    public void ProcessTransaction(BankingTransaction bt)
    {
        // Code not shown.
    }
}

//BankingTransaction is not a data contract class,
//but is an XmlSerializer-compatible class instead.
public class BankingTransaction
{
    [XmlAttribute]
    public string Operation;
    [XmlElement]
    public Account fromAccount;
    [XmlElement]
    public Account toAccount;
    [XmlElement]
    public int amount;
}
//Notice that the Account class must also be XmlSerializer-compatible.

<ServiceContract(), XmlSerializerFormat()> _
Public Class BankingService
    <OperationContract()> _
    Public Sub ProcessTransaction(ByVal bt As BankingTransaction)
        ' Code not shown.
    End Sub
End Class


' BankingTransaction is not a data contract class,
' but is an XmlSerializer-compatible class instead.

Public Class BankingTransaction
    <XmlAttribute()> _
    Public Operation As String
    <XmlElement()> _
    Public fromAccount As Account
    <XmlElement()> _
    Public toAccount As Account
    <XmlElement()> _
    Public amount As Integer
End Class
'Notice that the Account class must also be XmlSerializer-compatible.

Beveiligingsoverwegingen

De DataContractSerializer klasse serialiseert bijvoorbeeld alleen die leden die zijn gemarkeerd met het DataMemberAttribute kenmerk, wanneer het gegevenscontracttypen serialiseert. De XmlSerializer klasse serialiseert elk openbaar lid. Bekijk het type in de volgende code.

[DataContract]
public class Customer
{
    [DataMember]
    public string firstName;
    [DataMember]
    public string lastName;
    public string creditCardNumber;
}

<DataContract()> _
Public Class Customer
    <DataMember()> _
    Public firstName As String
    <DataMember()> _
    Public lastName As String
    Public creditCardNumber As String
End Class

Als het type per ongeluk wordt gebruikt in een servicecontract waarin de XmlSerializer klasse is geselecteerd, wordt het creditCardNumber lid geserialiseerd, wat waarschijnlijk niet bedoeld is.

Hoewel de DataContractSerializer klasse de standaardwaarde is, kunt u deze expliciet selecteren voor uw service (hoewel u dit nooit hoeft te doen) door het DataContractFormatAttribute kenmerk toe te passen op het servicecontracttype.

De serialisatiefunctie die wordt gebruikt voor de service is een integraal onderdeel van het contract en kan niet worden gewijzigd door een andere binding te selecteren of door andere configuratie-instellingen te wijzigen.

Andere belangrijke beveiligingsoverwegingen zijn van toepassing op de XmlSerializer klasse. Ten eerste wordt het ten zeerste aanbevolen dat elke WCF-toepassing die gebruikmaakt van de XmlSerializer klasse is ondertekend met een sleutel die wordt beveiligd tegen openbaarmaking. Deze aanbeveling is van toepassing wanneer zowel een handmatige als een automatische overschakeling naar het XmlSerializer wordt uitgevoerd (door Svcutil.exe, Servicereferentie toevoegen of een soortgelijk hulpmiddel). Dit komt doordat de XmlSerializer serialisatie-engine ondersteuning biedt voor het laden van vooraf gegenereerde serialisatieassembly's zolang ze zijn ondertekend met dezelfde sleutel als de toepassing. Een niet-ondertekende toepassing is volledig onbeveiligd tegen de mogelijkheid van een schadelijke assembly die overeenkomt met de verwachte naam van de vooraf gegenereerde serialisatieassembly die in de toepassingsmap of de algemene assemblycache wordt geplaatst. Natuurlijk moet een aanvaller eerst schrijftoegang krijgen tot een van deze twee locaties om deze actie uit te voeren.

Een andere bedreiging die bestaat wanneer u gebruikt XmlSerializer , is gerelateerd aan schrijftoegang tot de tijdelijke map van het systeem. De XmlSerializer-serialisatie-engine maakt en gebruikt in deze map tijdelijke serialisatieverzamelingen. Houd er rekening mee dat elk proces met schrijftoegang tot de tijdelijke map deze serialisatieassembly's met schadelijke code kan overschrijven.

Regels voor ondersteuning van XmlSerializer

U kunt niet rechtstreeks compatibele kenmerken toepassen XmlSerializerop contractbewerkingsparameters of retourwaarden. Ze kunnen echter worden toegepast op getypte berichten (berichtcontracttekstonderdelen), zoals wordt weergegeven in de volgende code.

[ServiceContract]
[XmlSerializerFormat]
public class BankingService
{
    [OperationContract]
    public void ProcessTransaction(BankingTransaction bt)
    {
        //Code not shown.
    }
}

[MessageContract]
public class BankingTransaction
{
    [MessageHeader]
    public string Operation;
    [XmlElement, MessageBodyMember]
    public Account fromAccount;
    [XmlElement, MessageBodyMember]
    public Account toAccount;
    [XmlAttribute, MessageBodyMember]
    public int amount;
}

<ServiceContract(), XmlSerializerFormat()> _
Public Class BankingService
    <OperationContract()> _
    Public Sub ProcessTransaction(ByVal bt As BankingTransaction)
        'Code not shown.
    End Sub
End Class

<MessageContract()> _
Public Class BankingTransaction
    <MessageHeader()> _
    Public Operation As String
    <XmlElement(), MessageBodyMember()> _
    Public fromAccount As Account
    <XmlElement(), MessageBodyMember()> _
    Public toAccount As Account
    <XmlAttribute(), MessageBodyMember()> _
    Public amount As Integer
End Class

Wanneer deze worden toegepast op getypte berichtleden, overschrijven deze kenmerken eigenschappen die conflicteren met de getypte berichtkenmerken. In de volgende code overschrijft ElementName bijvoorbeeld Name.

    [MessageContract]
    public class BankingTransaction
    {
        [MessageHeader] public string Operation;

        //This element will be <fromAcct> and not <from>:
        [XmlElement(ElementName="fromAcct"), MessageBodyMember(Name="from")]
        public Account fromAccount;

        [XmlElement, MessageBodyMember]
        public Account toAccount;

        [XmlAttribute, MessageBodyMember]
        public int amount;
}

<MessageContract()> _
Public Class BankingTransaction
    <MessageHeader()> _
    Public Operation As String

    'This element will be <fromAcct> and not <from>:
    <XmlElement(ElementName:="fromAcct"), _
        MessageBodyMember(Name:="from")> _
    Public fromAccount As Account

    <XmlElement(), MessageBodyMember()> _
    Public toAccount As Account

    <XmlAttribute(), MessageBodyMember()> _
    Public amount As Integer
End Class

Het MessageHeaderArrayAttribute kenmerk wordt niet ondersteund bij het gebruik van de XmlSerializer.

WCF biedt geen ondersteuning voor de SoapIncludeAttribute en XmlIncludeAttribute kenmerken in berichtcontracten en bewerkingscontracten. Gebruik in plaats daarvan het KnownTypeAttribute kenmerk.

Typen die de IXmlSerializable Interface implementeren

Typen die de IXmlSerializable interface implementeren, worden volledig ondersteund door de DataContractSerializer. Het XmlSchemaProviderAttribute kenmerk moet altijd worden toegepast op deze typen om hun schema te beheren.

Er zijn drie soorten typen die implementeren IXmlSerializable: typen die willekeurige inhoud vertegenwoordigen, typen die één element vertegenwoordigen en verouderde DataSet typen.

• Inhoudstypen gebruiken een schemaprovidermethode die is opgegeven door het XmlSchemaProviderAttribute kenmerk. De methode retourneert null niet en de IsAny eigenschap op het kenmerk blijft staan op de standaardwaarde van false. Dit is het meest voorkomende gebruik van IXmlSerializable typen.

• Elementtypen worden gebruikt wanneer een IXmlSerializable type de naam van een eigen hoofdelement moet beheren. Als u een type als elementtype wilt markeren, stelt u de eigenschap IsAny van het kenmerk XmlSchemaProviderAttribute in op true, of retourneert u null vanuit de methode van de schemaprovider. Het gebruik van een schemaprovidermethode is optioneel voor elementtypen – u kunt null gebruiken in plaats van de methodenaam in de XmlSchemaProviderAttribute. Als IsAnytrue is en er een schemaprovidermethode is opgegeven, moet de methode null retourneren.

• Verouderde DataSet typen zijn IXmlSerializable typen die niet zijn gemarkeerd met het XmlSchemaProviderAttribute kenmerk. In plaats daarvan zijn ze afhankelijk van de GetSchema methode voor het genereren van schema's. Dit patroon wordt gebruikt voor het DataSet type en de getypte gegevensset leidt een klasse af in eerdere versies van .NET Framework, maar is nu verouderd en wordt alleen ondersteund om verouderde redenen. Vertrouw niet op dit patroon en pas altijd de XmlSchemaProviderAttribute toe op uw IXmlSerializable typen.

IXmlSerializable-inhoudstypen

Bij het serialiseren van een gegevenslid van een type dat IXmlSerializable implementeert en een eerder gedefinieerd inhoudstype is, schrijft de serializer het wrapper-element voor het gegevenslid en draagt de controle over aan de WriteXml methode. De WriteXml implementatie kan elke XML schrijven, waaronder het toevoegen van kenmerken aan het wrapper-element. Nadat WriteXml voltooid is, sluit de serializer het element.

Bij het deserialiseren van een gegevenslid van een type dat IXmlSerializable implementeert en een inhoudstype is zoals eerder gedefinieerd, plaatst de deserializer de XML-lezer op het wrapper-element voor het gegevenslid en roept de ReadXml methode aan. De methode moet het hele element lezen, inclusief de begin- en eindtags. Zorg ervoor dat de ReadXml code het geval afhandelt waarin het element leeg is. Bovendien moet uw ReadXml implementatie niet vertrouwen op het wrapper-element dat op een specifieke manier genoemd wordt. De naam die door de serializer wordt gekozen kan variëren.

Het is toegestaan om inhoudstypen polymorf toe te wijzen IXmlSerializable , bijvoorbeeld aan gegevensleden van het type Object. Het is ook toegestaan dat de typeexemplaren null zijn. Ten slotte is het mogelijk om IXmlSerializable-typen te gebruiken met ingeschakelde objectgrafiekbewaring en met de NetDataContractSerializer. Voor al deze functies moet de WCF-serializer bepaalde kenmerken koppelen aan het wrapper-element ('nil' en 'type' in de naamruimte van het XML-schema-exemplaar en 'Id', 'Ref', 'Type' en 'Assembly' in een WCF-specifieke naamruimte).

Kenmerken die moeten worden genegeerd bij het implementeren van ReadXml

Voordat het besturingselement aan uw ReadXml code wordt doorgegeven, onderzoekt de deserializer het XML-element, detecteert deze speciale XML-kenmerken en handelt erop. Als 'nil' bijvoorbeeld true is, wordt een null-waarde gedeserialiseerd en ReadXml wordt niet aangeroepen. Als polymorfisme wordt gedetecteerd, wordt de inhoud van het element gedeserialiseerd alsof het een ander type is. De implementatie van ReadXml van het polymorf toegewezen type wordt aangeroepen. In elk geval moet een ReadXml implementatie deze speciale kenmerken negeren omdat deze worden verwerkt door de deserializer.

Schemaoverwegingen voor IXmlSerializable-inhoudstypen

Bij het exporteren van een schema en een IXmlSerializable inhoudstype wordt de methode van de schemaprovider aangeroepen. Er wordt een XmlSchemaSet doorgegeven aan de methode van de schemaprovider. De methode kan elk geldig schema toevoegen aan de schemaset. De schemaset bevat het schema dat al bekend is op het moment dat schema-export plaatsvindt. Wanneer de methode van de schemaprovider een item moet toevoegen aan de schemaset, moet deze bepalen of er al een XmlSchema met de juiste naamruimte in de set bestaat. Als dit het geval is, moet de methode van de schemaprovider het nieuwe item toevoegen aan het bestaande XmlSchema. Anders moet er een nieuwe XmlSchema instantie worden gemaakt. Dit is belangrijk als matrices van IXmlSerializable typen worden gebruikt. Als u bijvoorbeeld een IXmlSerializable-type hebt dat wordt geëxporteerd als type 'A' in naamruimte 'B', is het mogelijk dat tegen de tijd dat de schemaprovidermethode wordt aangeroepen, de schemaset al het schema voor 'B' bevat om het type "ArrayOfA" te ondersteunen.

Naast het toevoegen van typen aan de XmlSchemaSet, moet de methode van de schemaprovider voor inhoudstypen een niet-null-waarde retourneren. Het kan een XmlQualifiedName retourneert die de naam van het schematype aangeeft dat moet worden gebruikt voor het opgegeven IXmlSerializable type. Deze gekwalificeerde naam fungeert ook als de naam van het gegevenscontract en de naamruimte voor het type. Het is toegestaan om een type te retourneren dat niet direct in de schemaset bestaat wanneer de methode van de schemaprovider wordt geretourneerd. Er wordt echter verwacht dat tegen de tijd dat alle gerelateerde typen zijn geëxporteerd (de Export-methode wordt aangeroepen voor alle relevante typen op de XsdDataContractExporter en de Schemas-eigenschap wordt benaderd), het type in de schemaset aanwezig is. Het openen van de Schemas eigenschap voordat alle relevante Export aanroepen zijn gedaan, kan leiden tot een XmlSchemaException. Zie Schema's exporteren uit klassen voor meer informatie over het exportproces.

De methode van de schemaprovider kan ook het XmlSchemaType retourneren voor gebruik. Het type is al dan niet anoniem. Als het anoniem is, wordt het schema voor het IXmlSerializable type geëxporteerd als een anoniem type telkens wanneer het IXmlSerializable type wordt gebruikt als gegevenslid. Het IXmlSerializable type heeft nog steeds een naam en naamruimte voor een gegevenscontract. (Dit wordt bepaald zoals beschreven in namen van gegevenscontracten , behalve dat het DataContractAttribute kenmerk niet kan worden gebruikt om de naam aan te passen.) Als het niet anoniem is, moet het een van de typen in de XmlSchemaSet. Dit geval is gelijk aan het retourneren van het XmlQualifiedName type.

Daarnaast wordt een globale elementdeclaratie geëxporteerd voor het type. Als het kenmerk XmlRootAttribute niet op het type is toegepast, heeft het element dezelfde naam en naamruimte als het gegevenscontract en is de eigenschap true 'nillable'. De enige uitzondering hierop is de schemanaamruimte (http://www.w3.org/2001/XMLSchema): als het gegevenscontract van het type zich in deze naamruimte bevindt, bevindt het bijbehorende globale element zich in de lege naamruimte, omdat het verboden is om nieuwe elementen toe te voegen aan de schemanaamruimte. Als op het type het XmlRootAttribute kenmerk is toegepast, wordt de declaratie van het globale element geëxporteerd met behulp van het volgende: ElementNameen NamespaceIsNullable eigenschappen. De standaardinstellingen die worden toegepast met XmlRootAttribute, zijn de naam van het gegevenscontract, een lege naamruimte en 'nillable' als true.

Dezelfde regels voor declaratie van globale elementen zijn van toepassing op verouderde gegevenssettypen. Houd er rekening mee dat de XmlRootAttribute niet in staat is overschrijvingen van declaraties van globale elementen te voorkomen die via aangepaste code zijn toegevoegd, noch via de methode van de schemaprovider, noch voor XmlSchemaSet verouderde gegevenssettypen.

IXmlSerializable-elementtypen

IXmlSerializable elementtypen hebben ofwel de IsAny eigenschap ingesteld op true, of hun schemaprovidermethode retourneert null.

Het serialiseren en deserialiseren van een elementtype is vergelijkbaar met het serialiseren en deserialiseren van een inhoudstype. Er zijn echter enkele belangrijke verschillen:

• De WriteXml implementatie zal naar verwachting precies één element schrijven (dat natuurlijk meerdere onderliggende elementen kan bevatten). Het mag geen attributen schrijven buiten dit ene element, meerdere broerelementen of gemengde inhoud. Het element is mogelijk leeg.

• De ReadXml implementatie mag het wrapper-element niet lezen. Verwacht wordt dat het ene element dat WriteXml produceert, gelezen zal worden.

• Wanneer u een elementtype regelmatig serialiseert (bijvoorbeeld als gegevenslid in een gegevenscontract), voert de serializer een wrapper-element uit voordat het wordt aangeroepen WriteXml, net als bij inhoudstypen. Bij het serialiseren van een elementtype op het hoogste niveau voert de serializer normaal gesproken geen wrapper-element uit rond het element dat WriteXml schrijft, tenzij een hoofdnaam en naamruimte expliciet worden opgegeven bij het maken van de serialisatiefunctie in de DataContractSerializer of NetDataContractSerializer constructors. Zie Serialisatie en deserialisatie voor meer informatie.

• Wanneer u een elementtype op het hoogste niveau serialiseert zonder de hoofdnaam en naamruimte op te geven tijdens het construeren, doen WriteStartObject en WriteEndObject feitelijk niets en roept WriteObjectContentWriteXml aan. In deze modus kan het object dat wordt geserialiseerd niet worden null en kan niet polymorf worden toegewezen. Het behoud van objectgrafiek kan ook niet worden ingeschakeld en kan NetDataContractSerializer niet worden gebruikt.

• Wanneer u een elementtype deserialiseert op het hoogste niveau zonder de hoofdnaam en naamruimte op te geven tijdens het aanmaken, retourneert IsStartObjecttrue als het het begin van een element kan vinden. ReadObject met de parameter verifyObjectName ingesteld op true gedraagt zich op dezelfde manier als IsStartObject voordat het object daadwerkelijk wordt gelezen. ReadObject geeft vervolgens de controle door aan de ReadXml-methode.

Het schema dat wordt geëxporteerd voor elementtypen is hetzelfde als voor het XmlElement type zoals beschreven in een eerdere sectie, behalve dat de methode van de schemaprovider elk extra schema kan toevoegen aan het XmlSchemaSet type, net als bij inhoudstypen. Het gebruik van het XmlRootAttribute kenmerk met elementtypen is niet toegestaan en globale elementdeclaraties worden nooit verzonden voor deze typen.

Verschillen met xmlSerializer

De IXmlSerializable interface en de XmlSchemaProviderAttributeXmlRootAttribute kenmerken worden ook begrepen door de XmlSerializer . Er zijn echter enkele verschillen in hoe deze worden behandeld in het gegevenscontractmodel. De belangrijke verschillen worden samengevat in de volgende lijst:

• De methode van de schemaprovider moet openbaar zijn om te worden gebruikt in de XmlSerializer, maar hoeft niet openbaar te zijn om te worden gebruikt in het gegevenscontractmodel.

• De methode van de schemaprovider wordt aangeroepen wanneer IsAny zich true in het gegevenscontractmodel bevindt, maar niet bij de XmlSerializer.

• Wanneer het XmlRootAttribute kenmerk niet aanwezig is voor inhoud of verouderde gegevenssettypen, exporteert u XmlSerializer een globale elementdeclaratie in de lege naamruimte. In het gegevenscontractmodel is de gebruikte naamruimte normaal gesproken de naamruimte van het gegevenscontract, zoals eerder is beschreven.

Houd rekening met deze verschillen bij het maken van typen die worden gebruikt met beide serialisatietechnologieën.

IXmlSerializable Schema importeren

Bij het importeren van een schema dat is gegenereerd op basis van IXmlSerializable typen, zijn er enkele mogelijkheden:

• Het gegenereerde schema kan een geldig gegevenscontractschema zijn, zoals beschreven in Data Contract Schema Reference. In dit geval kan het schema worden geïmporteerd zoals gebruikelijk en worden reguliere gegevenscontracttypen gegenereerd.

• Het gegenereerde schema is mogelijk geen geldig gegevenscontractschema. Uw schemaprovidermethode kan bijvoorbeeld een schema genereren dat XML-kenmerken omvat die niet worden ondersteund in het gegevenscontractmodel. In dit geval kunt u als IXmlSerializable typen het schema importeren. Deze importmodus is niet standaard ingeschakeld, maar kan eenvoudig worden ingeschakeld, bijvoorbeeld met de /importXmlTypes opdrachtregelschakelaar naar het hulpprogramma voor metagegevens van ServiceModel (Svcutil.exe). Dit wordt gedetailleerd beschreven in het importschema voor het genereren van klassen. Houd er rekening mee dat u rechtstreeks met de XML voor uw typeexemplaren moet werken. U kunt ook overwegen om een andere serialisatietechnologie te gebruiken die ondersteuning biedt voor een breder scala aan schema's. Zie het onderwerp over het gebruik van de XmlSerializer.

• Mogelijk wilt u uw bestaande IXmlSerializable typen opnieuw gebruiken in de proxy in plaats van nieuwe typen te genereren. In dit geval kan de functie waarnaar wordt verwezen in het importschema voor het genereren van typen worden gebruikt om aan te geven welk type opnieuw moet worden gebruikt. Dit komt overeen met het gebruik van de /reference schakelaar op svcutil.exe, waarmee de assembly wordt opgegeven die de typen bevat die moeten worden hergebruikt.

Oorspronkelijk gedrag van XmlSerializer

In .NET Framework 4.0 en eerder heeft de XmlSerializer tijdelijke serialisatieassembly's gegenereerd door C#-code naar een bestand te schrijven. Het bestand is vervolgens gecompileerd tot een assembly. Dit gedrag had enkele ongewenste gevolgen, zoals het vertragen van de opstarttijd voor de serializer. In .NET Framework 4.5 is dit gedrag gewijzigd om de assembly's te genereren zonder gebruik van de compiler. Sommige ontwikkelaars willen mogelijk de gegenereerde C#-code zien. U kunt opgeven dat dit verouderde gedrag moet worden gebruikt door de volgende configuratie:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.xml.serialization>
    <xmlSerializer tempFilesLocation='e:\temp\XmlSerializerBug' useLegacySerializerGeneration="true" />
  </system.xml.serialization>
  <system.diagnostics>
    <switches>
      <add name="XmlSerialization.Compilation" value="1" />
    </switches>
  </system.diagnostics>
</configuration>

Als u compatibiliteitsproblemen ondervindt, zoals wanneer XmlSerializer een afgeleide klasse met een niet-openbare overschrijving niet kan serialiseren, kunt u met behulp van de volgende configuratie terugkeren naar het oude gedrag:

<configuration>
  <appSettings>
    <add key="System:Xml:Serialization:UseLegacySerializerGeneration" value="true" />
  </appSettings>
</configuration>

Als alternatief voor de bovenstaande configuratie kunt u de volgende configuratie gebruiken op een computer met .NET Framework 4.5 of hoger:

<configuration>
  <system.xml.serialization>
    <xmlSerializer useLegacySerializerGeneration="true"/>
  </system.xml.serialization>
</configuration>

Zie ook

• DataContractFormatAttribute
• DataContractSerializer
• XmlSerializer
• MessageHeaderArrayAttribute
• Het specificeren van gegevensoverdracht in servicecontracten
• Gegevenscontracten gebruiken
• Procedure: De opstarttijd van WCF-clienttoepassingen verbeteren met behulp van xmlSerializer