System.Xml.Serialization.XmlSerializer-klass

XML-serialisering är processen att konvertera ett objekts offentliga egenskaper och fält till ett serieformat (i det här fallet XML) för lagring eller transport. Deserialisering återskapar objektet i dess ursprungliga tillstånd från XML-utdata. Du kan tänka dig serialisering som ett sätt att spara tillståndet för ett objekt i en dataström eller buffert. Till exempel använder XmlSerializer ASP.NET klassen för att koda XML-webbtjänstmeddelanden.

Data i dina objekt beskrivs med hjälp av programmeringsspråkkonstruktioner som klasser, fält, egenskaper, primitiva typer, matriser och till och med inbäddad XML i form av XmlElement eller XmlAttribute objekt. Du kan välja att skapa egna klasser, kommenterat med attribut eller använda XML-schemadefinitionsverktyget (Xsd.exe) för att generera klasserna baserat på ett befintligt XML-schemadefinitionsdokument (XSD). Om du har ett XML-schema kan du köra Xsd.exe för att skapa en uppsättning klasser som är starkt inskrivna i schemat och kommenteras med attribut för att följa schemat när det serialiseras.

För att överföra data mellan objekt och XML krävs en mappning från programmeringsspråkkonstruktionerna till XML-schemat och från XML-schemat till programmeringsspråkkonstruktionerna. Den XmlSerializer och närliggande verktyg som Xsd.exe tillhandahåller bryggan mellan dessa två tekniker både vid designtid och körningstid. Vid designtillfället använder du Xsd.exe för att skapa ett XML-schemadokument (.xsd) från dina anpassade klasser eller för att skapa klasser från ett visst schema. I båda fallen kommenteras klasserna med anpassade attribut för att instruera XmlSerializer hur systemet mappar mellan XML-schemasystemet och den gemensamma språkkörningen. Under körning kan instanser av klasserna serialiseras till XML-dokument som följer det angivna schemat. På samma sätt kan dessa XML-dokument deserialiseras till körningsobjekt. Observera att XML-schemat är valfritt och inte krävs vid designtid eller körning.

Kontrollera genererad XML

Om du vill styra den genererade XML-koden kan du använda särskilda attribut för klasser och medlemmar. Om du till exempel vill ange ett annat XML-elementnamn använder du ett XmlElementAttribute för ett offentligt fält eller en egenskap och anger egenskapen ElementName . En fullständig lista över liknande attribut finns i Attribut som styr XML-serialisering. Du kan också implementera IXmlSerializable gränssnittet för att styra XML-utdata.

Om XML-koden som genereras måste överensstämma med avsnitt 5 i World Wide Consortium-dokumentet , SOAP (Simple Object Access Protocol) 1.1, måste du skapa XmlSerializer med en XmlTypeMapping. Om du vill kontrollera den kodade SOAP XML-koden ytterligare använder du attributen som anges i Attribut som styr kodad SOAP-serialisering.

Med XmlSerializer kan du dra nytta av att arbeta med starkt typade klasser och fortfarande ha flexibiliteten i XML. Med hjälp av fält eller egenskaper av typen XmlElement, XmlAttribute eller XmlNode i dina starkt skrivna klasser, kan du läsa delar av XML-dokumentet direkt till XML-objekt.

Om du arbetar med utökningsbara XML-scheman kan du också använda attributen XmlAnyElementAttribute och XmlAnyAttributeAttribute för att serialisera och deserialisera element eller attribut som inte finns i det ursprungliga schemat. Om du vill använda objekten använder du ett XmlAnyElementAttribute på ett fält som returnerar en matris med XmlElement objekt eller tillämpar ett XmlAnyAttributeAttribute på ett fält som returnerar en matris med XmlAttribute objekt.

Om en egenskap eller ett fält returnerar ett komplext objekt (till exempel en matris eller en klassinstans) XmlSerializer konverteras det till ett element som är kapslat i xml-huvuddokumentet. Till exempel returnerar den första klassen i följande kod en instans av den andra klassen.

Public Class MyClass
    Public MyObjectProperty As MyObject
End Class

Public Class MyObject
    Public ObjectName As String
End Class

public class MyClass
{
    public MyObject MyObjectProperty;
}
public class MyObject
{
    public string ObjectName;
}

De serialiserade XML-utdata ser ut så här:

<MyClass>
  <MyObjectProperty>
  <ObjectName>My String</ObjectName>
  </MyObjectProperty>
</MyClass>

Om ett schema innehåller ett element som är valfritt (minOccurs = '0'), eller om schemat innehåller ett standardvärde, har du två alternativ. Ett alternativ är att använda System.ComponentModel.DefaultValueAttribute för att ange standardvärdet, som du ser i följande kod.

Public Class PurchaseOrder
    <System.ComponentModel.DefaultValueAttribute ("2002")> _
    Public Year As String
End Class

public class PurchaseOrder
{
    [System.ComponentModel.DefaultValueAttribute ("2002")]
    public string Year;
}

Ett annat alternativ är att använda ett särskilt mönster för att skapa ett booleskt fält som känns igen av XmlSerializer, och att tillämpa på XmlIgnoreAttribute fältet. Mönstret skapas i form av propertyNameSpecified. Om det till exempel finns ett fält med namnet "MyFirstName", ska du även skapa ett fält med namnet "MyFirstNameSpecified" som instruerar XmlSerializer om huruvida XML-elementet med namnet "MyFirstName" ska genereras. Detta visas i följande exempel.

Public Class OptionalOrder
    ' This field's value should not be serialized
    ' if it is uninitialized.
    Public FirstOrder As String

    ' Use the XmlIgnoreAttribute to ignore the
    ' special field named "FirstOrderSpecified".
    <System.Xml.Serialization.XmlIgnoreAttribute> _
    Public FirstOrderSpecified As Boolean
End Class

public class OptionalOrder
{
    // This field should not be serialized
    // if it is uninitialized.
    public string FirstOrder;

    // Use the XmlIgnoreAttribute to ignore the
    // special field named "FirstOrderSpecified".
    [System.Xml.Serialization.XmlIgnoreAttribute]
    public bool FirstOrderSpecified;
}

Åsidosätt standard serialisering

Du kan också åsidosätta serialiseringen av en uppsättning objekt och deras fält och egenskaper genom att skapa ett av lämpliga attribut och lägga till det i en instans av XmlAttributes klassen. Åsidosättande serialisering på det här sättet har två användningsområden: för det första kan du styra och utöka serialiseringen av objekt som finns i en DLL, även om du inte har åtkomst till källan. för det andra kan du skapa en uppsättning serialiserbara klasser, men serialisera objekten på flera sätt. Mer information finns i XmlAttributeOverrides klassen och Så här kontrollerar du serialisering av härledda klasser.

För att serialisera ett objekt, anropa Serialize-metoden. Om du vill deserialisera ett objekt anropar du Deserialize metoden.

Information om hur du lägger till XML-namnområden i ett XML-dokument finns i XmlSerializerNamespaces.

Du måste ha behörighet att skriva till den temporära katalogen (enligt definitionen i temp-miljövariabeln) för att deserialisera ett objekt.

Dynamiskt genererade sammansättningar

För att öka prestandan genererar XML-serialiseringsinfrastrukturen dynamiskt sammansättningar för att serialisera och deserialisera angivna typer. Infrastrukturen hittar och återanvänder dessa sammansättningar. Det här beteendet inträffar endast när du använder följande konstruktorer:

XmlSerializer.XmlSerializer(Type)

XmlSerializer.XmlSerializer(Type, String)

Om du använder någon av de andra konstruktorerna genereras flera versioner av samma sammansättning och tas aldrig bort, vilket resulterar i en minnesläcka och dåliga prestanda. Den enklaste lösningen är att använda en av de tidigare nämnda två konstruktorerna. Annars måste du cachelagra sammansättningarna i en Hashtable, som du ser i följande exempel.

Hashtable serializers = new Hashtable();

// Use the constructor that takes a type and XmlRootAttribute.
XmlSerializer s = new XmlSerializer(typeof(MyClass), myRoot);

// Implement a method named GenerateKey that creates unique keys
// for each instance of the XmlSerializer. The code should take
// into account all parameters passed to the XmlSerializer
// constructor.
object key = GenerateKey(typeof(MyClass), myRoot);

// Check the local cache for a matching serializer.
XmlSerializer ser = (XmlSerializer)serializers[key];
if (ser == null)
{
    ser = new XmlSerializer(typeof(MyClass), myRoot);
    // Cache the serializer.
    serializers[key] = ser;
}

// Use the serializer to serialize or deserialize.

Dim serializers As New Hashtable()

' Use the constructor that takes a type and XmlRootAttribute.
Dim s As New XmlSerializer(GetType([MyClass]), myRoot)

' Implement a method named GenerateKey that creates unique keys
' for each instance of the XmlSerializer. The code should take
' into account all parameters passed to the XmlSerializer
' constructor.
Dim key As Object = GenerateKey(GetType([MyClass]), myRoot)

' Check the local cache for a matching serializer.
Dim ser As XmlSerializer = CType(serializers(key), XmlSerializer)

If ser Is Nothing Then
    ser = New XmlSerializer(GetType([MyClass]), myRoot)
    ' Cache the serializer.
    serializers(key) = ser
End If

' Use the serializer to serialize or deserialize.

Serialisering av ArrayList och allmän lista

Det är inte möjligt för XmlSerializer att serialisera eller deserialisera följande:

• Matriser med ArrayList
• Matriser med List<T>

Serialisering av uppräkningar av osignerad Long

Det XmlSerializer går inte att instansiera för att serialisera en uppräkning om följande villkor är sanna: Uppräkningen är av typen osignerad lång (ulong i C#) och uppräkningen innehåller alla medlemmar med ett värde som är större än 9 223 372 036 854 775 807. Följande kan till exempel inte serialiseras.

public enum LargeNumbers: ulong
{
    a = 9223372036854775808
}
// At runtime, the following code will fail.
xmlSerializer mySerializer=new XmlSerializer(typeof(LargeNumbers));

Föråldrade typer

Klassen XmlSerializer serialiserar inte objekt som är markerade som [Obsolete].