Dela via

Schemaimport och export

  • Artikel

Windows Communication Foundation (WCF) innehåller en ny serialiseringsmotor, DataContractSerializer. Översätter DataContractSerializer mellan .NET Framework-objekt och XML (i båda riktningarna). Förutom själva serialiseraren innehåller WCF associerade mekanismer för schemaimport och schemaexport. Schemat är en formell, exakt och maskinläsbar beskrivning av formen på XML som serialiseraren producerar eller som deserialiseraren kan komma åt. WCF använder W3C(World Wide Web Consortium) XML Schema definition language (XSD) som sin schemarepresentation, vilket är mycket samverkande med många plattformar från tredje part.

Schemaimportkomponenten, XsdDataContractImporter, tar ett XSD-schemadokument och genererar .NET Framework-klasser (normalt datakontraktsklasser) så att de serialiserade formulären motsvarar det angivna schemat.

Till exempel följande schemafragment:

XsdDataContractImporter importer = new XsdDataContractImporter();
importer.Options.Namespaces.Add(new KeyValuePair<string, string>("http://schemas.contoso.com/carSchema", "Contoso.Cars"));

Dim importer As New XsdDataContractImporter
importer.Options.Namespaces.Add(New KeyValuePair(Of String, String)("http://schemas.contoso.com/carSchema", "Contoso.Cars"))

genererar följande typ (förenklad något för bättre läsbarhet).

[DataContract]
public partial class Vehicle : IExtensibleDataObject
{
    private int yearField;
    private string colorField;

    [DataMember]
    public int year
    {
        get { return this.yearField; }
        set { this.yearField = value; }
    }
    [DataMember]
    public string color
    {
        get { return this.colorField; }
        set { this.colorField = value; }
    }

    private ExtensionDataObject extensionDataField;
    public ExtensionDataObject ExtensionData
    {
        get { return this.extensionDataField; }
        set { this.extensionDataField = value; }
    }
}

Partial Class Vehicle
    Implements IExtensibleDataObject

    Private yearField As Integer
    Private colorField As String

    <DataMember()> _
    Public Property year() As Integer
        Get
            Return Me.yearField
        End Get
        Set
            Me.yearField = value
        End Set
    End Property

    <DataMember()> _
    Public Property color() As String
        Get
            Return Me.colorField
        End Get
        Set
            Me.colorField = value
        End Set
    End Property
    Private extensionDataField As ExtensionDataObject

    Public Property ExtensionData() As ExtensionDataObject _
        Implements IExtensibleDataObject.ExtensionData
        Get
            Return Me.extensionDataField
        End Get
        Set(ByVal value As ExtensionDataObject)
            Me.extensionDataField = value
        End Set
    End Property
End Class

Observera att den genererade typen följer flera metodtips för datakontrakt (finns i Metodtips: Versionshantering av datakontrakt):

  • Typen implementerar IExtensibleDataObject gränssnittet. Mer information finns i Framåtkompatibla datakontrakt.

  • Datamedlemmar implementeras som offentliga egenskaper som omsluter privata fält.

  • Klassen är en partiell klass och du kan göra tillägg utan att ändra genererad kod.

Gör XsdDataContractExporter att du kan göra det omvända – ta typer som är serialiserbara med DataContractSerializer och generera ett XSD-schemadokument.

Återgivning garanteras inte

Det är inte garanterat att schema eller typer gör en tur och retur med total återgivning. (En tur och retur-resa innebär att importera ett schema för att skapa en uppsättning klasser och exportera resultatet för att skapa ett schema igen.) Samma schema kanske inte returneras. Att återställa processen är inte heller garanterat att bevara återgivningen. (Exportera en typ för att generera schemat och importera sedan tillbaka typen. Det är osannolikt att samma typ returneras.)

Typer som stöds

Datakontraktsmodellen stöder endast en begränsad delmängd av WC3-schemat. Alla scheman som inte överensstämmer med den här delmängden orsakar ett undantag under importprocessen. Det finns till exempel inget sätt att ange att en datamedlem i ett datakontrakt ska serialiseras som ett XML-attribut. Därför stöds inte scheman som kräver användning av XML-attribut och orsakar undantag under importen, eftersom det är omöjligt att generera ett datakontrakt med rätt XML-projektion.

Följande schemafragment kan till exempel inte importeras med hjälp av standardinställningarna för import.

<xs:complexType name="Vehicle">
  <xs:sequence>
    <xs:element name="year" type="xs:int" />
    <xs:element name="color" type="xs:string" />
  </xs:sequence>
  <xs:attribute name="engineHorsePower" type="xs:int" />
</xs:complexType>

Mer information finns i Schemareferens för datakontrakt. Om ett schema inte överensstämmer med reglerna för datakontrakt använder du en annan serialiseringsmotor. Till exempel använder den XmlSerializer egna separata mekanismen för schemaimport. Det finns också ett särskilt importläge där schemat som stöds utökas. Mer information finns i avsnittet om hur du genererar IXmlSerializable typer i Importera schema för att generera klasser.

Stöder XsdDataContractExporter alla .NET Framework-typer som kan serialiseras med DataContractSerializer. Mer information finns i Typer som stöds av Data Contract Serializer. Observera att schemat som genereras med hjälp av XsdDataContractExporter är normalt giltiga data som XsdDataContractImporter kan användas (om inte XmlSchemaProviderAttribute används för att anpassa schemat).

Mer information om hur du använder finns i XsdDataContractImporterImportera schema för att generera klasser.

Mer information om hur du använder finns i XsdDataContractExporterExportera scheman från klasser.

Se även