Import und Export von SchemasSchema Import and Export

Windows Communication Foundation (WCF) umfasst eine neue Serialisierungs-Engine, die DataContractSerializer.Windows Communication Foundation (WCF) includes a new serialization engine, the DataContractSerializer. Die DataContractSerializer zwischen .NET Framework-Objekten und XML (in beide Richtungen) übersetzt.The DataContractSerializer translates between .NET Framework objects and XML (in both directions). Zusätzlich zum Serialisierungsprogramm selbst enthält WCF zugeordneten Schema-Import / Export-Mechanismen Schema.In addition to the serializer itself, WCF includes associated schema import and schema export mechanisms. Schema ist eine formale, genaue und maschinenlesbare Beschreibung der Form des XML-Codes, die das Serialisierungsprogramm erstellt oder auf das Deserialisierungsprogramm zugreifen kann.Schema is a formal, precise, and machine-readable description of the shape of XML that the serializer produces or that the deserializer can access. WCF verwendet die World Wide Web Consortium (W3C) XML-Schemadefinitionssprache (XSD) als schemadarstellung, die mit zahlreichen Plattformen von Drittanbietern weitgehend interoperabel ist.WCF uses the World Wide Web Consortium (W3C) XML Schema definition language (XSD) as its schema representation, which is widely interoperable with numerous third-party platforms.

Die schemaimportkomponente XsdDataContractImporter, nimmt ein XSD-Schema-Dokument an und generiert .NET Framework-Klassen (normalerweise datenvertragsklassen), dass die serialisierten Formen dem angegebenen Schema entsprechen.The schema import component, XsdDataContractImporter, takes an XSD schema document and generates .NET Framework classes (normally data contract classes) such that the serialized forms correspond to the given schema.

Das folgende Schemafragment:For example, the following schema fragment:

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"))

generiert beispielsweise den folgenden Typ (zugunsten einer besseren Lesbarkeit leicht vereinfacht).generates the following type (simplified slightly for better readability).

[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 

Beachten Sie, dass der generierte Typ mehreren empfohlenen Vorgehensweisen für Datenverträge folgt (finden Sie im Best Practices: Versionsverwaltung von Datenverträgen):Note that the generated type follows several data contract best practices (found in Best Practices: Data Contract Versioning):

  • Der Typ implementiert die IExtensibleDataObject-Schnittstelle.The type implements the IExtensibleDataObject interface. Weitere Informationen finden Sie unter Aufwärtskompatible Datenverträge.For more information, see Forward-Compatible Data Contracts.

  • Datenmember werden als öffentliche Eigenschaften implementiert, die private Felder umschließen.Data members are implemented as public properties that wrap private fields.

  • Die Klasse ist eine partielle Klasse, und Hinzufügungen können vorgenommen werden, ohne generierten Code zu ändern.The class is a partial class, and additions can be made without modifying generated code.

Mit XsdDataContractExporter können Sie umgekehrt verfahren und anhand von Typen, die mit DataContractSerializer serialisierbar sind, ein XSD-Schemadokument generieren.The XsdDataContractExporter enables you to do the reverse—take types that are serializable with the DataContractSerializer and generate an XSD Schema document.

Keine Garantie für die OriginaltreueFidelity Is Not Guaranteed

Bei einem Roundtrip wird keine Garantie für die Originaltreue von Schemas oder Typen übernommen.It is not guaranteed that schema or types make a round trip with total fidelity. (Ein Roundtrip Mittel zum Importieren eines Schemas zum Erstellen einer Reihe von Klassen und zum export des Ergebnisses zum Erstellen eines Schemas.) Das gleiche Schema wird möglicherweise nicht zurückgegeben.(A round trip means to import a schema to create a set of classes, and export the result to create a schema again.) The same schema may not be returned. Auch bei der Umkehrung des Prozesses ist eine Beibehaltung der Originaltreue nicht garantiert.Reversing the process is also not guaranteed to preserve fidelity. (Exportieren Sie einen Typ, um sein Schema zu generieren, und importieren Sie den Typ dann wieder zurück.(Export a type to generate its schema, and then import the type back. Es ist unwahrscheinlich, dass der gleiche Typ zurückgegeben wird.)It is unlikely the same type is returned.)

Unterstützte TypenSupported Types

Das Datenvertragsmodell unterstützt nur eine beschränkte Teilmenge des WC3-Schemas.The data contract model supports only a limited subset of the WC3 schema. Jedes Schema, das dieser Teilmenge nicht entspricht, verursacht während des Importprozesses eine Ausnahme.Any schema that does not conform to this subset will cause an exception during the import process. Es gibt beispielsweise keine Möglichkeit festzulegen, dass ein Datenmember eines Datenvertrags als XML-Attribut serialisiert werden soll.For example, there is no way to specify that a data member of a data contract should be serialized as an XML attribute. Schemas, die XML-Attribute erfordern, werden daher nicht unterstützt und verursachen beim Import Ausnahmen, da es nicht möglich ist, einen Datenvertrag mit der richtigen XML-Projektion zu generieren.Thus, schemas that require the use of XML attributes are not supported and will cause exceptions during import, because it is impossible to generate a data contract with the correct XML projection.

Das folgende Schemafragment kann z. B. nicht mit den Standardimporteinstellungen importiert werden.For example, the following schema fragment cannot be imported using the default import settings.

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

Weitere Informationen finden Sie unter Datenvertrags-Schemareferenz.For more information, see Data Contract Schema Reference. Wenn ein Schema den Datenvertragsregeln nicht entspricht, verwenden Sie eine andere Serialisierungs-Engine.If a schema does not conform to the data contract rules, use a different serialization engine. XmlSerializer verwendet z. B. einen eigenen separaten Schemaimportmechanismus.For example, the XmlSerializer uses its own separate schema import mechanism. Außerdem gibt es einen speziellen Importmodus, durch den weitere Schemas unterstützt werden.Also, there is a special import mode in which the range of supported schema is expanded. Weitere Informationen finden Sie im Abschnitt zum Generieren von IXmlSerializable Typen im Importieren von Schemas zum Generieren von Klassen.For more information, see the section about generating IXmlSerializable types in Importing Schema to Generate Classes.

Die XsdDataContractExporter unterstützt .NET Framework-Typen, die mit serialisiert werden können die DataContractSerializer.The XsdDataContractExporter supports any .NET Framework types that can be serialized with the DataContractSerializer. Weitere Informationen finden Sie unter Types Supported by the Data Contract Serializer.For more information, see Types Supported by the Data Contract Serializer. Beachten Sie, dass mit XsdDataContractExporter generierte Schemas normalerweise gültige Daten sind, die von XsdDataContractImporter verwendet werden können (sofern XmlSchemaProviderAttribute nicht zur Anpassung des Schemas verwendet wird).Note that schema generated using the XsdDataContractExporter is normally valid data that the XsdDataContractImporter can use (unless the XmlSchemaProviderAttribute is used to customize the schema).

Weitere Informationen zur Verwendung der XsdDataContractImporter, finden Sie unter Importieren von Schemas zum Generieren von Klassen.For more information about using the XsdDataContractImporter, see Importing Schema to Generate Classes.

Weitere Informationen zur Verwendung der XsdDataContractExporter, finden Sie unter Exportieren von Schemas aus Klassen.For more information about using the XsdDataContractExporter, see Exporting Schemas from Classes.

Siehe auchSee also