Importieren von Schemas zum Generieren von Klassen

Zum Generieren von Klassen aus Schemas, die mit Windows Communication Foundation (WCF), verwenden Sie die XsdDataContractImporter Klasse. In diesem Thema werden der Prozess und die Variationen beschrieben.

Der Importprozess

Der schemaimportprozess beginnt mit einem XmlSchemaSet und erzeugt eine CodeCompileUnit.

XmlSchemaSet ist Teil des SOM (Schemaobjektmodell) von .NET Framework, das eine Gruppe von XSD-Schemadokumenten (XML Schema Definition Language) darstellt. Erstellen einer XmlSchemaSet -Objekt aus einer Gruppe von XSD-Dokumenten, deserialisieren Sie jedes Dokument in ein XmlSchema Objekt (mit der XmlSerializer) und fügen Sie diese Objekte einem neuen XmlSchemaSet.

CodeCompileUnit ist Teil des CodeDOM (Code-Dokumentobjektmodell) von .NET Framework, das den .NET Framework-Code abstrakt darstellt. Generieren Sie den eigentlichen Code aus einer CodeCompileUnit, verwenden Sie eine Unterklasse von der CodeDomProvider Klasse, z. B. die CSharpCodeProvider oder VBCodeProvider Klasse.

So importieren Sie ein Schema

  1. Erstellen Sie eine Instanz der XsdDataContractImporter.

  2. Optional. Übergeben Sie im Konstruktor eine CodeCompileUnit. Die während des Schemaimports generierten Typen werden dieser CodeCompileUnit-Instanz hinzugefügt. Es wird keine leere CodeCompileUnit verwendet.

  3. Optional. Rufen Sie eine von der CanImport Methoden. Die Methode bestimmt, ob es sich beim jeweiligen Schema um ein gültiges Datenvertragsschema handelt und ob es importiert werden kann. Die CanImport-Methode verfügt über die gleichen Überladungen wie Import (der nächste Schritt).

  4. Rufen Sie eine der überladenen Import Methoden, z. B. die Import(XmlSchemaSet) Methode.

    Bei der einfachsten Überladung wird ein XmlSchemaSet verwendet, und es werden alle Typen importiert, die im Schemasatz enthalten sind, einschließlich anonyme Typen. Anderen Überladungen können Sie den XSD-Typ oder eine Liste der Typen importieren angeben (in Form einer XmlQualifiedName oder eine Auflistung von XmlQualifiedName Objekte). In diesem Fall werden nur die angegebenen Typen importiert. Eine Überladung verwendet ein XmlSchemaElement importiert ein bestimmtes Element aus der XmlSchemaSet, einschließlich des dazugehörigen Typs (anonym oder nicht anonym). Diese Überladung gibt einen XmlQualifiedName zurück, der für den Datenvertragsnamen des Typs steht, der für dieses Element generiert wurde.

    Mehrere Aufrufe der Import-Methode führen dazu, dass mehrere Elemente derselben CodeCompileUnit hinzugefügt werden. Ein Typ wird nicht für den CodeCompileUnit generiert, wenn er darin bereits vorhanden ist. Rufen Sie Import für einen XsdDataContractImporter mehrfach auf, anstatt mehrere XsdDataContractImporter-Objekte zu verwenden. Dies ist die empfohlene Möglichkeit, um die Generierung von doppelten Typen zu vermeiden.

    Hinweis

    Wenn beim Importieren ein Fehler auftritt, befindet sich die CodeCompileUnit in einem unvorhersehbaren Zustand. Wenn Sie eine CodeCompileUnit verwenden, die aus einem fehlgeschlagenen Import stammt, kann Sie dies ggf. anfällig für Sicherheitslücken machen.

  5. Zugriff der CodeCompileUnit über die CodeCompileUnit Eigenschaft.

Importoptionen: Anpassen der generierten Typen

Lassen sich die Options Eigenschaft der XsdDataContractImporter mit einer Instanz von der ImportOptions Klasse, um verschiedene Aspekte des Importprozesses zu steuern. Verschiedene Optionen wirken sich direkt auf die generierten Typen aus.

Steuern der Zugriffsebene (GenerateInternal oder der Schalter "/internal")

Dies entspricht der / interne wechseln Sie auf die ServiceModel Metadata Utility Tool (Svcutil.exe).

Normalerweise werden öffentliche Typen aus Schemas generiert, indem private Felder und passende Eigenschaften öffentlicher Datenmember verwendet werden. Um stattdessen interne Typen generieren möchten, legen Sie die GenerateInternal -Eigenschaft true.

Das folgende Beispiel zeigt ein Schema transformiert in eine interne Klasse, wenn die GenerateInternal -Eigenschaft auf festgelegt isttrue.

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

    [DataMember] internal int year {
        get {return this.yearField;}
        set {this.yearField=value;}
    }
[DataMember] internal string color{
        get {return this.colorField;}
        set {this.colorField=value;}
    }
    
    private ExtensionDataObject extensionDataField;
    public ExtensionDataObject ExtensionData {
        get {return this.extensionDataField;}
        set {this.extensionDataField=value;}
    }
}
Class Vehicle
    Implements IExtensibleDataObject 
    Private yearField As Integer
    Private colorField As String
    
    <DataMember()>  _
    Friend Property year() As Integer 
        Get
            Return Me.yearField
        End Get
        Set
            Me.yearField = value
        End Set
    End Property
    
    <DataMember()>  _
    Friend 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 

Steuern von Namespaces (Namespaces oder der Schalter "/namespace")

Dies entspricht der /Namespace schalten die Svcutil.exe Tool.

Normalerweise werden aus dem Schema generierte Typen generiert, in .NET Framework Namespaces mit jedem XSD-Namespace, die entsprechend einer bestimmten .NET Framework Namespace in der beschriebenen Zuordnung Datenvertrags-Schemareferenz. Sie können diese Zuordnung durch Anpassen der Namespaces Eigenschaft, um ein Dictionary<TKey,TValue>.</TKey, TValue> Wenn ein bestimmter XSD-Namespace im Wörterbuch enthalten ist, wird auch der entsprechende .NET Framework-Namespace aus Ihrem Wörterbuch verwendet.

Betrachten Sie zum Beispiel das folgende Schema:

Im folgenden Beispiel wird die Namespaces-Eigenschaft verwendet, um den http://schemas.contoso.com/carSchema-Namespace "Contoso.Cars" zuzuordnen.

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

Hinzufügen von SerializableAttribute (GenerateSerializable oder der Schalter "/serializable")

Dies entspricht der / serializable schalten die Svcutil.exe Tool.

Manchmal ist es wichtig, dass die aus dem Schema generierten Typen mit verwendet werden .NET Framework Laufzeitmodule Serialisierung (z. B. die System.Runtime.Serialization.Formatters.Binary.BinaryFormatter und SoapFormatter Klassen). Dies ist hilfreich, wenn Sie Typen für das .NET Framework-Remoting nutzen. Um dies zu ermöglichen, müssen Sie anwenden der SerializableAttribute -Attribut auf die generierten Typen zusätzlich zum normalen DataContractAttribute Attribut. Das Attribut wird automatisch generiert, wenn die Importoption GenerateSerializable auf true festgelegt ist.

Das folgende Beispiel zeigt die Vehicle-Klasse, bei deren Generierung die Importoption GenerateSerializable auf true festgelegt ist.

[DataContract]
[Serializable]
public partial class Vehicle : IExtensibleDataObject
{
    // Code not shown.
    public ExtensionDataObject ExtensionData
    {
        get
        {
            throw new Exception("The method or operation is not implemented.");
        }
        set
        {
            throw new Exception("The method or operation is not implemented.");
        }
    }
}
<DataContract(), Serializable()>  _
Partial Class Vehicle
    Implements IExtensibleDataObject 
    Private extensionDataField As ExtensionDataObject
    
    ' Code not shown.
    
    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 

Hinzufügen von Datenbindungsunterstützung (EnableDataBinding oder der Schalter „/enableDataBinding“)

Dies entspricht der /enableDataBinding Tool Svcutil.exe wechseln.

In einigen Fällen kann es ratsam sein, die aus dem Schema generierten Typen an Komponenten der grafischen Benutzeroberfläche zu binden, damit die Aktualisierungen der Instanzen dieser Typen automatisch auf der Benutzeroberfläche widergespiegelt werden. Die XsdDataContractImporter -Typen, die implementieren Generieren der INotifyPropertyChanged Schnittstelle so, dass es sich bei jeder Änderung der Eigenschaft ein Ereignis auslöst. Beim Generieren von Typen für die Verwendung mit einer Client-UI-Programmierumgebung, die diese Schnittstelle unterstützt (z. B. Windows Presentation Foundation (WPF)), legen die EnableDataBinding -Eigenschaft true zum Aktivieren dieser Funktion.

Das folgende Beispiel zeigt die Vehicle Klasse generiert, mit der EnableDataBinding festgelegt true.

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

    [DataMember] public int year {
        get {return this.yearField;}
        set {
            if (this.yearField.Equals(value) != true) {
                this.yearField = value;
                this.RaisePropertyChanged("year");
            }
}
    }
[DataMember] public string color{
        get {return this.colorField;}
        set {
            if (this.colorField.Equals(value) != true) {
                this.colorField = value;
                this.RaisePropertyChanged("color");
            }
}
    }
    
    public event PropertyChangedEventHandler PropertyChanged;
    protected void RaisePropertyChanged (string propertyName) {
        PropertyChangedEventHandler propertyChanged = 
this.PropertyChanged;
        if (propertyChanged != null) {
            propertyChanged(this, 
new PropertyChangedEventArgs(propertyName));
        }
    }

    private ExtensionDataObject extensionDataField;
    public ExtensionDataObject ExtensionData {
        get {return this.extensionDataField;}
        set {this.extensionDataField=value;}
    }
}
Partial Class Vehicle
    Implements IExtensibleDataObject, INotifyPropertyChanged 
    Private yearField As Integer
    Private colorField As String
    
    <DataMember()>  _
    Public Property year() As Integer 
        Get
            Return Me.yearField
        End Get
        Set
            If Me.yearField.Equals(value) <> True Then
                Me.yearField = value
                Me.RaisePropertyChanged("year")
            End If
        End Set
    End Property
    
    <DataMember()>  _
    Public Property color() As String 
        Get
            Return Me.colorField
        End Get
        Set
            If Me.colorField.Equals(value) <> True Then
                Me.colorField = value
                Me.RaisePropertyChanged("color")
            End If
        End Set
    End Property
    
    Public Event PropertyChanged As PropertyChangedEventHandler _
      Implements INotifyPropertyChanged.PropertyChanged
    
    Private Sub RaisePropertyChanged(ByVal propertyName As String) 
         RaiseEvent PropertyChanged(Me, _
          New PropertyChangedEventArgs(propertyName))    
    End Sub 
    
    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 

Importoptionen: Wählen von Auflistungstypen

Zwei spezielle XML-Muster stellen Auflistungen von Elementen dar: Listen mit Elementen und Zuordnungen zwischen einem Element und einem anderen. Unten ist ein Beispiel für eine Liste mit Zeichenfolgen angegeben.

Das folgende Beispiel zeigt eine Zuordnung zwischen einer Zeichenfolge und einer Ganzzahl (city name und population).

Hinweis

Jede Zuordnung kann auch als Liste angesehen werden. Sie können die oben angegebene Zuordnung zum Beispiel als Liste mit komplexen city-Objekten ansehen, die zwei Felder aufweisen (ein Zeichenfolgenfeld und ein Ganzzahlfeld). Beide Muster verfügen im XSD-Schema über eine Darstellung. Es ist nicht möglich, zwischen einer Liste und einer Zuordnung zu unterscheiden. Aus diesem Grund werden Muster dieser Art immer wie Listen behandelt, es sei denn, das Schema enthält eine bestimmte WCF-spezifische Anmerkung. Die Anmerkung gibt an, dass ein bestimmtes Muster eine Zuordnung darstellt. Weitere Informationen finden Sie unterDatenvertrags-Schemareferenz.

In der Regel wird eine Liste als Auflistungsdatenvertrag importiert, der von einer generischen Liste oder einem .NET Framework-Array abgeleitet ist. Dies hängt davon ab, ob das Schema das standardmäßige Namensmuster für Auflistungen verwendet. Dies wird ausführlicher beschrieben Sammlungstypen in Datenverträgen. Zuordnungen werden normalerweise entweder als ein Dictionary<TKey,TValue> oder auflistungsdatenvertrag, die vom Wörterbuchobjekt abgeleitet ist.</TKey, TValue> Betrachten Sie zum Beispiel das folgende Schema:

Der Import wird hierbei wie folgt durchgeführt (aus Gründen der besseren Lesbarkeit werden anstelle von Eigenschaften Felder angezeigt).

[DataContract] public partial class Vehicle : IExtensibleDataObject
{
    [DataMember] public int yearField;
    [DataMember] public string colorField;
    [DataMember] public people passengers;

    // Other code not shown.

    public ExtensionDataObject ExtensionData
    {
        get
        {
            throw new Exception("The method or operation is not implemented.");
        }
        set
        {
            throw new Exception("The method or operation is not implemented.");
        }
    }
}
[CollectionDataContract(ItemName="person")]
public class people : List<string> {}
Public Partial Class Vehicle
    Implements IExtensibleDataObject 

    <DataMember()>  _
    Public yearField As Integer
    <DataMember()>  _
    Public colorField As String
    <DataMember()>  _
    Public passengers As people
    
    ' Other code not shown.
    
    Public Property ExtensionData() As ExtensionDataObject _
    Implements IExtensibleDataObject.ExtensionData
        Get
            Throw New Exception("The method or operation is not implemented.")
        End Get
        Set
            Throw New Exception("The method or operation is not implemented.")
        End Set
    End Property
End Class

<CollectionDataContract(ItemName := "person")>  _
Public Class people
    Inherits List(Of String)
End Class 

Es ist möglich, die Auflistungstypen anzupassen, die für Schemamuster dieser Art generiert werden. Sie möchten z. B. Ableiten von Auflistungen Generieren der BindingList<T> statt der List<T> Klasse, um die Typen in ein Listenfeld zu binden, und es werden automatisch aktualisiert, wenn der Inhalt der Auflistung ändern. Legen Sie hierzu die ReferencedCollectionTypes Eigenschaft der ImportOptions Klasse, um eine Liste der Auflistungstypen (im weiteren als referenzierten Typen bezeichnet) verwendet werden. Beim Importieren von Auflistungen wird diese Liste mit Verweisen zu Auflistungstypen durchsucht und die Auflistung mit der höchsten Übereinstimmung verwendet, falls vorhanden. Zuordnungen nur für Typen, die generische oder die nicht generische Implementierung, Übereinstimmungen IDictionary Schnittstelle, während alle unterstützten Auflistungstypen Listen gegenübergestellt werden.

Z. B. wenn die ReferencedCollectionTypes -Eigenschaft auf festgelegt ist ein BindingList<T>, people Typ im vorherigen Beispiel wie folgt generiert.

[CollectionDataContract(ItemName = "person")]
public class people : BindingList<string> { }
<CollectionDataContract(ItemName := "person")>  _
Public Class people
    Inherits BindingList(Of String)

Ein geschlossener generischer Typ wird als beste Übereinstimmung betrachtet. Zum Beispiel wenn die Typen BindingList(Of Integer) und ArrayList übergeben werden in die Auflistung der referenzierten Typen werden alle Listen mit Ganzzahlen, die im Schema als importiert eine BindingList(Of Integer). Alle anderen Listen, zum Beispiel List(Of String), werden als ArrayList importiert.

Wenn ein Typ, der die generische IDictionary-Schnittstelle implementiert, der Auflistung der referenzierten Typen hinzugefügt wird, müssen ihre Typparameter entweder vollständig offen oder vollständig geschlossen sein.

Duplikate sind nicht zulässig. Zum Beispiel können Sie den referenzierten Typen nicht sowohl eine List(Of Integer) als auch eine Collection(Of Integer) hinzufügen. In diesem Fall wäre es unmöglich zu bestimmen, welches Element verwendet werden soll, wenn im Schema eine Liste mit Ganzzahlen gefunden wird. Duplikate werden nur erkannt, wenn es einen Typ im Schema gibt, der das Duplikatproblem offenlegt. Wenn das importierte Schema zum Beispiel keine Listen mit Ganzzahlen enthält, ist es zulässig, sowohl die List(Of Integer) als auch die Collection(Of Integer) in der Auflistung mit den referenzierten Typen zu verwenden, aber beide haben keine Auswirkung.

Der Mechanismus mit den referenzierten Auflistungstypen funktioniert ebenso gut für Auflistungen mit komplexen Typen (einschließlich Auflistungen anderer Auflistungen), nicht nur für Auflistungen von primitiven Typen.

Die ReferencedCollectionTypes Eigenschaft entspricht der /collectionType Tool SvcUtil.exe wechseln. Beachten Sie, dass mehrere Auflistungstypen verweisen die /collectionType Switch mehrmals angegeben werden muss. Wenn der Typ nicht in der Datei mscorlib.dll enthalten ist, die Assembly muss auch verwiesen werden mithilfe der /reference wechseln.

Importoptionen: Verweisen auf vorhandene Typen

In einigen Fällen entsprechen Typen im Schema vorhandenen .NET Framework-Typen, und es ist nicht erforderlich, diese Typen ganz neu zu generieren. (Dieser Abschnitt gilt nur für Typen, bei denen es sich nicht um Auflistungstypen handelt. Auflistungstypen finden Sie im vorherigen Abschnitt.)

Es kann zum Beispiel sein, dass Sie über einen standardmäßigen unternehmensweiten Datenvertragstyp "Person" verfügen, der beim Darstellen einer Person immer verwendet werden soll. Jedes Mal, wenn ein Dienst diesen Typ verwendet und das dazugehörige Schema in den Dienstmetadaten erscheint, sollten Sie den vorhandenen Person-Typ beim Importieren des Schemas wiederverwenden, anstatt für jeden Dienst ein neues Schema zu erstellen.

Hierzu übergeben Sie eine Liste der .NET Framework Typen, die Sie wiederverwenden, an die Auflistung möchten der ReferencedTypes -Eigenschaft zurückgibt, auf die ImportOptions Klasse. Falls einige dieser Typen einen Datenvertragsnamen und Namespace aufweisen, der mit dem Namen und Namespace eines Schematyps übereinstimmt, wird ein Strukturvergleich durchgeführt. Wenn ermittelt wird, dass die Typen über übereinstimmende Namen und Strukturen verfügen, wird der vorhandene .NET Framework-Typ wiederverwendet und kein neuer Typ generiert. Wenn nur der Name übereinstimmt, aber nicht die Struktur, wird eine Ausnahme ausgelöst. Beachten Sie, dass beim Verweisen auf Typen (zum Beispiel beim Hinzufügen von neuen optionalen Datenmembern) kein Spielraum für unterschiedliche Versionen besteht. Die Strukturen müssen genau übereinstimmen.

Es ist zulässig, der Auflistung der referenzierten Typen mehrere Typen mit demselben Datenvertragsnamen und Namespace hinzuzufügen, solange keine Schematypen mit diesem Namen und Namespace importiert werden. So können Sie der Auflistung alle in einer Assembly enthaltenen Typen auf einfache Weise hinzufügen, ohne sich um Duplikate von Typen kümmern zu müssen, die im Schema eigentlich nicht vorkommen.

Die ReferencedTypes Eigenschaft entspricht der /reference bei bestimmten Verwendungsarten des Tools Svcutil.exe wechseln.

Hinweis

Bei Verwendung von Svcutil.exe oder (im Visual Studio) der Hinzufügen eines Dienstverweises verwenden, alle Typen in der Datei MsCorLib.dll automatisch referenziert.

Importoptionen: Importieren von Nicht-DataContract-Schemas als IXmlSerializable-Typen

Die XsdDataContractImporter unterstützt eine beschränkte Teilmenge des Schemas. Wenn nicht unterstützte Schemakonstrukte vorhanden sind (zum Beispiel XML-Attribute), schlägt der Importversuch mit einer Ausnahme fehl. Festlegen der ImportXmlType -Eigenschaft true erweitert den Bereich des Schemas unterstützt. Bei Festlegung auf true, XsdDataContractImporter generiert Typen, implementieren die IXmlSerializable Schnittstelle. Auf diese Weise wird der Direktzugriff auf die XML-Darstellung dieser Typen aktiviert.

Entwurfsüberlegungen
  • Es kann schwierig sein, direkt mit der schwach typisierten XML-Darstellung zu arbeiten. Erwägen Sie ein alternatives Serialisierungsmodul, wie z. B. die XmlSerializer, um mit Schemas, die nicht kompatibel mit Verträgen mit starker Typisierung arbeiten. Weitere Informationen finden Sie unterVerwenden der XmlSerializer-Klasse.

  • Einige Schemakonstrukte können nicht importiert werden, indem die XsdDataContractImporter , auch wenn die ImportXmlType -Eigenschaft auf festgelegt ist true. In diesem Fall sollten Sie mithilfe der XmlSerializer in solchen Fällen.

  • Die genauen Schemakonstrukte, die unterstützt sowohl beim ImportXmlType ist true oder false in beschriebenen Datenvertrags-Schemareferenz.

  • Schemas für generierte IXmlSerializable werden Typen nicht beibehalten Genauigkeit beim importiert und exportiert werden. Wenn Sie das Schema also aus den generierten Typen exportieren und jeweils als Klasse importieren, wird nicht das Originalschema zurückgegeben.

Es ist möglich, kombinieren Sie die ImportXmlType -Option mit der ReferencedTypes zuvor beschriebene Option. Für Typen, die als generiert IXmlSerializable Implementierungen, die strukturelle Überprüfung wird übersprungen, wenn mit der ReferencedTypes Funktion.

Die ImportXmlType Option entspricht der /importXmlTypes Tool Svcutil.exe wechseln.

Arbeiten mit generierten IXmlSerializable-Typen

Die generierte IXmlSerializable Typen enthalten ein privates Feld mit der Bezeichnung "NodesField", die gibt ein Array von XmlNode Objekte. Beim Deserialisieren der Instanz eines Typs dieser Art können Sie auf die XML-Daten direkt über dieses Feld zugreifen, indem Sie das XML-Dokumentobjektmodell verwenden. Beim Serialisieren einer Instanz dieses Typs können Sie dieses Feld auf die gewünschten XML-Daten festlegen. Es wird dann serialisiert.

Dies wird mithilfe der IXmlSerializable-Implementierung erreicht. In der generierten IXmlSerializable Typ, der ReadXml Implementierung ruft die ReadNodes Methode der XmlSerializableServices Klasse. Die Methode ist eine Hilfsmethode, die durch bereitgestellten XML-Daten konvertiert ein XmlReader in ein Array von XmlNode Objekte. Die WriteXml Implementierung bewirkt das Gegenteil und konvertiert das Array mit XmlNode Objekte in eine Sequenz von XmlWriter aufrufen. Dies geschieht mithilfe der WriteNodes Methode.

Es ist möglich, den Schemaexportprozess über die generierten IXmlSerializable-Klassen auszuführen. Wie bereits erwähnt, erhalten Sie nicht das ursprüngliche Schema zurück. Stattdessen erhalten Sie den standardmäßigen XSD-Typ "anyType" zurück, der ein Platzhalter für einen beliebigen XSD-Typ ist.

Dies erfolgt durch Anwenden der XmlSchemaProviderAttribute -Attribut auf die generierten IXmlSerializable Klassen und gibt eine Methode aufruft, die AddDefaultSchema Methode, um den Typ "AnyType" zu generieren.

Hinweis

Die XmlSerializableServices Typ vorhanden ist, ausschließlich, um diese Funktion zu unterstützen. Es ist nicht ratsam, den Typ zu einem anderen Zweck zu verwenden.

Importoptionen: Erweiterte Optionen

Bei den folgenden Optionen handelt es sich um erweiterte Importoptionen:

  • CodeProvider Eigenschaft. Geben Sie die CodeDomProvider zu verwenden, um den Code für die generierten Klassen zu generieren. Der Importmechanismus versucht, vermeiden Sie Funktionen, die CodeDomProvider nicht unterstützt. Zum Beispiel unterstützt die Programmiersprache J# keine Generika. Wenn Sie den J#-Codeanbieter in dieser Eigenschaft angeben, wird keine generischen Typen in des Importer generiert CodeCompileUnit. Wenn die CodeProvider nicht festgelegt ist, den vollständigen Satz von .NET Framework -Funktionen ohne Einschränkungen verwendet.

  • DataContractSurrogate Eigenschaft. Ein IDataContractSurrogate Implementierung kann mit dieser Eigenschaft angegeben werden. Die IDataContractSurrogate passt den Importprozess an. Weitere Informationen finden Sie unterDatenvertrag-Ersatzzeichen. Standardmäßig wird kein Ersatzzeichen verwendet.

Siehe auch

DataContractSerializer
XsdDataContractImporter
XsdDataContractExporter
ImportOptions
Datenvertrags-Schemareferenz
Datenvertrag-Ersatzzeichen
Schema importieren und exportieren
Exportieren von Schemas aus Klassen
Datenvertrags-Schemareferenz