Import und Export von SchemasSchema Import and Export

Windows Communication Foundation (WCF) enthält ein neues Serialisierungsmodul, das DataContractSerializer.Windows Communication Foundation (WCF) includes a new serialization engine, the DataContractSerializer. DataContractSerializer übersetzt zwischen .NET Framework.NET Framework-Objekten und XML (in beide Richtungen).The DataContractSerializer translates between .NET Framework.NET Framework objects and XML (in both directions). Zusätzlich zum Serialisierungsprogramm selbst umfasst 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 die Serialisierung erstellt oder auf die 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 das World Wide Web Consortium (W3C) XML-Schemadefinitionssprache (XSD) als die schemendarstellung, 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 generiert anhand eines XSD-Schemadokuments .NET Framework.NET Framework-Klassen (normalerweise Datenvertragsklassen), sodass die serialisierten Formen dem angegebenen Schema entsprechen.The schema import component, XsdDataContractImporter, takes an XSD schema document and generates .NET Framework.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 (gefunden Vorgehensweisen: 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- wird der import eines Schemas zum Erstellen einer Gruppe von Klassen und export des Ergebnisses zum Erstellen eines Schemas bezeichnet.) 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 ein anderes Serialisierungsmodul.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, der die Bandbreite unterstützter Schemata erweitert.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.

XsdDataContractExporter unterstützt alle .NET Framework.NET Framework-Typen, die mit DataContractSerializer serialisiert werden können.The XsdDataContractExporter supports any .NET Framework.NET Framework types that can be serialized with the DataContractSerializer. Weitere Informationen finden Sie unter Typen unterstützt, durch den Datenvertragsserialisierer.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 zum Verwenden 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 zum Verwenden 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

DataContractSerializer
XsdDataContractImporter
XsdDataContractExporter
Importieren von Schemas zum Generieren von KlassenImporting Schema to Generate Classes
Exportieren von Schemas aus KlassenExporting Schemas from Classes