Importieren von Schemas zum Generieren von KlassenImporting Schema to Generate Classes

Um aus Schemas Klassen zu generieren, die mit Windows Communication Foundation (WCF)Windows Communication Foundation (WCF) genutzt werden können, verwenden Sie die XsdDataContractImporter-Klasse.To generate classes from schemas that are usable with Windows Communication Foundation (WCF)Windows Communication Foundation (WCF), use the XsdDataContractImporter class. In diesem Thema werden der Prozess und die Variationen beschrieben.This topic describes the process and variations.

Der ImportprozessThe Import Process

Der Schemaimportprozess beginnt mit XmlSchemaSet und erzeugt ein CodeCompileUnit-Element.The schema import process starts with an XmlSchemaSet and produces a CodeCompileUnit.

XmlSchemaSet ist Teil des SOM (Schemaobjektmodell) von .NET Framework.NET Framework, das eine Gruppe von XSD-Schemadokumenten (XML Schema Definition Language) darstellt.The XmlSchemaSet is a part of the .NET Framework.NET Framework’s Schema Object Model (SOM) that represents a set of XML Schema definition language (XSD) schema documents. Um ein XmlSchemaSet-Objekt aus einer Gruppe von XSD-Dokumenten zu erstellen, deserialisieren Sie die einzelnen Dokumente in ein XmlSchema-Objekt (mithilfe von XmlSerializer) und fügen diese Objekte einem neuen XmlSchemaSet-Element hinzu.To create an XmlSchemaSet object from a set of XSD documents, deserialize each document into an XmlSchema object (using the XmlSerializer) and add these objects to a new XmlSchemaSet.

CodeCompileUnit ist Teil des CodeDOM (Code-Dokumentobjektmodell) von .NET Framework.NET Framework, das den .NET Framework.NET Framework-Code abstrakt darstellt.The CodeCompileUnit is part of the .NET Framework.NET Framework’s Code Document Object Model (CodeDOM) that represents .NET Framework.NET Framework code in an abstract way. Um den eigentlichen Code aus einer CodeCompileUnit zu generieren, verwenden Sie eine Unterklasse der CodeDomProvider-Klasse, zum Beispiel die CSharpCodeProvider- oder VBCodeProvider-Klasse.To generate the actual code from a CodeCompileUnit, use a subclass of the CodeDomProvider class, such as the CSharpCodeProvider or VBCodeProvider class.

So importieren Sie ein SchemaTo import a schema

  1. Erstellen Sie eine Instanz von XsdDataContractImporter.Create an instance of the XsdDataContractImporter.

  2. Dies ist optional.Optional. Übergeben Sie im Konstruktor eine CodeCompileUnit.Pass a CodeCompileUnit in the constructor. Die während des Schemaimports generierten Typen werden dieser CodeCompileUnit-Instanz hinzugefügt. Es wird keine leere CodeCompileUnit verwendet.The types generated during schema import are added to this CodeCompileUnit instance instead of starting with a blank CodeCompileUnit.

  3. Dies ist optional.Optional. Rufen Sie eine der CanImport-Methoden auf.Call one of the CanImport methods. Die Methode bestimmt, ob es sich beim jeweiligen Schema um ein gültiges Datenvertragsschema handelt und ob es importiert werden kann.The method determines whether the given schema is a valid data contract schema and can be imported. Die CanImport-Methode verfügt über die gleichen Überladungen wie Import (der nächste Schritt).The CanImport method has the same overloads as Import (the next step).

  4. Rufen Sie eine der überladenen Import-Methoden auf, zum Beispiel die Import(XmlSchemaSet)-Methode.Call one of the overloaded Import methods, for example, the Import(XmlSchemaSet) method.

    Bei der einfachsten Überladung wird ein XmlSchemaSet verwendet, und es werden alle Typen importiert, die im Schemasatz enthalten sind, einschließlich anonyme Typen.The simplest overload takes an XmlSchemaSet and imports all types, including anonymous types, found in that schema set. Bei anderen Überladungen können Sie den XSD-Typ oder eine Liste der Typen angeben, die importiert werden sollen (in Form eines XmlQualifiedName-Objekts oder einer Auflistung mit XmlQualifiedName-Objekten).Other overloads allow you to specify the XSD type or a list of types to import (in the form of an XmlQualifiedName or a collection of XmlQualifiedName objects). In diesem Fall werden nur die angegebenen Typen importiert.In this case, only the specified types are imported. Eine Überladung verwendet ein XmlSchemaElement, das ein bestimmtes Element aus dem XmlSchemaSet importiert, einschließlich des dazugehörigen Typs (anonym oder nicht anonym).An overload takes an XmlSchemaElement that imports a particular element out of the XmlSchemaSet, as well as its associated type (whether it is anonymous or not). Diese Überladung gibt einen XmlQualifiedName zurück, der für den Datenvertragsnamen des Typs steht, der für dieses Element generiert wurde.This overload returns an XmlQualifiedName, which represents the data contract name of the type generated for this element.

    Mehrere Aufrufe der Import-Methode führen dazu, dass mehrere Elemente derselben CodeCompileUnit hinzugefügt werden.Multiple calls of the Import method result in multiple items being added to the same CodeCompileUnit. Ein Typ wird nicht für den CodeCompileUnit generiert, wenn er darin bereits vorhanden ist.A type is not generated into the CodeCompileUnit if it already exists there. Rufen Sie Import für einen XsdDataContractImporter mehrfach auf, anstatt mehrere XsdDataContractImporter-Objekte zu verwenden.Call Import multiple times on the same XsdDataContractImporter instead of using multiple XsdDataContractImporter objects. Dies ist die empfohlene Möglichkeit, um die Generierung von doppelten Typen zu vermeiden.This is the recommended way to avoid duplicate types being generated.

    Hinweis

    Wenn beim Importieren ein Fehler auftritt, befindet sich die CodeCompileUnit in einem unvorhersehbaren Zustand.If there is a failure during import, the CodeCompileUnit will be in an unpredictable state. Wenn Sie eine CodeCompileUnit verwenden, die aus einem fehlgeschlagenen Import stammt, kann Sie dies ggf. anfällig für Sicherheitslücken machen.Using a CodeCompileUnit resulting from a failed import could expose you to security vulnerabilities.

  5. Greifen Sie auf die CodeCompileUnit mithilfe der CodeCompileUnit-Eigenschaft zu.Access the CodeCompileUnit through the CodeCompileUnit property.

Importoptionen: Anpassen der generierten TypenImport Options: Customizing the Generated Types

Sie können die Options-Eigenschaft von XsdDataContractImporter auf eine Instanz der ImportOptions-Klasse festlegen, um verschiedene Aspekte des Importprozesses zu steuern.You can set the Options property of the XsdDataContractImporter to an instance of the ImportOptions class to control various aspects of the import process. Verschiedene Optionen wirken sich direkt auf die generierten Typen aus.A number of options directly influence the types that are generated.

Steuern der Zugriffsebene (GenerateInternal oder der Schalter "/internal")Controlling the Access Level (GenerateInternal or the /internal switch)

Dies entspricht der / internal wechseln Sie auf die ServiceModel Metadata Utility Tool (Svcutil.exe).This corresponds to the /internal switch on the ServiceModel Metadata Utility Tool (Svcutil.exe).

Normalerweise werden öffentliche Typen aus Schemas generiert, indem private Felder und passende Eigenschaften öffentlicher Datenmember verwendet werden.Normally, public types are generated from schema, with private fields and matching public data member properties. Wenn Sie stattdessen interne Typen generieren möchten, legen Sie die GenerateInternal-Eigenschaft auf true fest.To generate internal types instead, set the GenerateInternal property to true.

Das folgende Beispiel zeigt ein Schema, das in eine interne Klasse umgewandelt wird, wenn die GenerateInternal-Eigenschaft auf true. festgelegt ist.The following example shows a schema transformed into an internal class when the GenerateInternal property is set to true.

[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")Controlling Namespaces (Namespaces or the /namespace switch)

Dies entspricht der /Namespace wechseln Sie auf die Svcutil.exe Tool.This corresponds to the /namespace switch on the Svcutil.exe tool.

Normalerweise werden aus dem Schema generierte Typen generiert, in .NET Framework.NET Framework Namespaces mit jeder XSD-Namespace zu einem bestimmten entspricht .NET Framework.NET Framework in beschriebenen Zuordnung Datenvertrags-Schemareferenz.Normally, types generated from schema are generated into .NET Framework.NET Framework namespaces, with each XSD namespace corresponding to a particular .NET Framework.NET Framework namespace according to a mapping described in Data Contract Schema Reference. Sie können diese Zuordnung mithilfe der Namespaces-Eigenschaft eines Dictionary<TKey,TValue> anpassen.You can customize this mapping by the Namespaces property to a Dictionary<TKey,TValue>. Wenn ein bestimmter XSD-Namespace im Wörterbuch enthalten ist, wird auch der entsprechende .NET Framework.NET Framework-Namespace aus Ihrem Wörterbuch verwendet.If a given XSD namespace is found in the dictionary, the matching .NET Framework.NET Framework namespace is also taken from your dictionary.

Betrachten Sie zum Beispiel das folgende Schema:For example, consider the following schema.

<xs:schema targetNamespace="http://schemas.contoso.com/carSchema">
  <xs:complexType name="Vehicle">
    <!-- details omitted... -->
  </xs:complexType>
</xs:schema>

Im folgenden Beispiel wird die Namespaces-Eigenschaft verwendet, um den http://schemas.contoso.com/carSchema-Namespace "Contoso.Cars" zuzuordnen.The following example uses the Namespaces property to map the "http://schemas.contoso.com/carSchema" namespace to "Contoso.Cars".

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")Adding the SerializableAttribute (GenerateSerializable or the /serializable switch)

Dies entspricht der / serializable wechseln Sie auf die Svcutil.exe Tool.This corresponds to the /serializable switch on the Svcutil.exe tool.

In einigen Fällen kann es wichtig sein, dass die aus dem Schema generierten Typen mit .NET Framework.NET Framework-Laufzeitserialisierungsmodulen verwendet werden können (zum Beispiel mit den Klassen System.Runtime.Serialization.Formatters.Binary.BinaryFormatter und SoapFormatter).Sometimes it is important for the types generated from the schema to be usable with .NET Framework.NET Framework runtime serialization engines (for example, the System.Runtime.Serialization.Formatters.Binary.BinaryFormatter and the SoapFormatter classes). Dies ist hilfreich, wenn Sie Typen für das .NET Framework.NET Framework-Remoting nutzen.This is useful when using types for .NET Framework.NET Framework remoting. Um dies zu aktivieren, müssen Sie das SerializableAttribute-Attribut zusätzlich zum normalen DataContractAttribute-Attribut auf die generierten Typen anwenden.To enable this, you must apply the SerializableAttribute attribute to the generated types in addition to the regular DataContractAttribute attribute. Das Attribut wird automatisch generiert, wenn die Importoption GenerateSerializable auf true festgelegt ist.The attribute is generated automatically if the GenerateSerializable import option is set to true.

Das folgende Beispiel zeigt die Vehicle-Klasse, bei deren Generierung die Importoption GenerateSerializable auf true festgelegt ist.The following example shows the Vehicle class generated with the GenerateSerializable import option set to true.

[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“)Adding Data Binding Support (EnableDataBinding or the /enableDataBinding switch)

Dies entspricht der /enableDataBinding auf das Tool Svcutil.exe wechseln.This corresponds to the /enableDataBinding switch on the Svcutil.exe tool.

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.Sometimes, you may want to bind the types generated from the schema to graphical user interface components so that any update to instances of these types will automatically update the UI. Der XsdDataContractImporter kann Typen generieren, die die INotifyPropertyChanged-Schnittstelle so implementieren, dass alle Änderungen von Eigenschaften ein Ereignis auslösen.The XsdDataContractImporter can generate types that implement the INotifyPropertyChanged interface in such a way that any property change triggers an event. Wenn Sie Typen für die Verwendung mit einer Programmierumgebung für die Clientbenutzeroberfläche generieren, die diese Schnittstelle unterstützt (zum Beispiel Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF)), legen Sie die EnableDataBinding-Eigenschaft zum Aktivieren dieser Funktion auf true fest.If you are generating types for use with a client UI programming environment that supports this interface (such as Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF)), set the EnableDataBinding property to true to enable this feature.

Das folgende Beispiel zeigt die Vehicle-Klasse, bei deren Generierung EnableDataBinding auf true festgelegt ist.The following example shows the Vehicle class generated with the EnableDataBinding set to 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 AuflistungstypenImport Options: Choosing Collection Types

Zwei spezielle XML-Muster stellen Auflistungen von Elementen dar: Listen mit Elementen und Zuordnungen zwischen einem Element und einem anderen.Two special patterns in XML represent collections of items: lists of items and associations between one item and another. Unten ist ein Beispiel für eine Liste mit Zeichenfolgen angegeben.The following is an example of a list of strings.

<People>
  <person>Alice</person>
  <person>Bob</person>
  <person>Charlie</person>
</People>

Das folgende Beispiel zeigt eine Zuordnung zwischen einer Zeichenfolge und einer Ganzzahl (city name und population).The following is an example of an association between a string and an integer (city name and population).

<Cities>
  <city>
    <name>Auburn</name>
    <population>40000</population>
  </city>
  <city>
    <name>Bellevue</name>
    <population>80000</population>
  </city>
  <city>
    <name>Cedar Creek</name>
    <population>10000</population>
  </city>
</Cities>

Hinweis

Jede Zuordnung kann auch als Liste angesehen werden.Any association could also be considered a list. 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).For example, you can view the preceding association as a list of complex city objects that happen to have two fields (a string field and an integer field). Beide Muster verfügen im XSD-Schema über eine Darstellung.Both patterns have a representation in the XSD Schema. 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 WCFWCF-spezifische Anmerkung.There is no way to differentiate between a list and an association, so such patterns are always treated as lists unless a special annotation specific to WCFWCF is present in the schema. Die Anmerkung gibt an, dass ein bestimmtes Muster eine Zuordnung darstellt.The annotation indicates that a given pattern represents an association. Weitere Informationen finden Sie unterFor more information, seeDatenvertrags-Schemareferenz. Data Contract Schema Reference.

In der Regel wird eine Liste als Auflistungsdatenvertrag importiert, der von einer generischen Liste oder einem .NET Framework.NET Framework-Array abgeleitet ist. Dies hängt davon ab, ob das Schema das standardmäßige Namensmuster für Auflistungen verwendet.Normally, a list is imported as a collection data contract that derives from a Generic List or as a .NET Framework.NET Framework array, depending on whether or not the schema follows the standard naming pattern for collections. Dies wird ausführlicher beschrieben Sammlungstypen in Datenverträgen.This is described in more detail in Collection Types in Data Contracts. Zuordnungen werden normalerweise entweder als Dictionary<TKey,TValue> oder als Auflistungsdatenvertrag importiert, der vom Wörterbuchobjekt abgeleitet ist.Associations are normally imported as either a Dictionary<TKey,TValue> or a collection data contract that derives from the dictionary object. Betrachten Sie zum Beispiel das folgende Schema:For example, consider the following schema.

<xs:complexType name="Vehicle">
  <xs:sequence>
    <xs:element name="year" type="xs:int"/>
    <xs:element name="color" type="xs:string"/>
    <xs:element name="passengers" type="people"/>
  </xs:sequence>
</xs:complexType>
<xs:complexType name="people">
  <xs:sequence>
    <xs:element name="person" type="xs:string" maxOccurs="unbounded" />
  </xs:sequence>
</xs:complexType>

Der Import wird hierbei wie folgt durchgeführt (aus Gründen der besseren Lesbarkeit werden anstelle von Eigenschaften Felder angezeigt).This would be imported as follows (fields are shown instead of properties for readability).

[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.It is possible to customize the collection types that are generated for such schema patterns. Es kann beispielsweise sein, dass Sie Auflistungen generieren, die von BindingList<T> abgeleitet sind, anstatt von der List<T>-Klasse, um den Typ an ein Listenfeld zu binden und automatisch aktualisieren zu lassen, wenn sich der Inhalt der Auflistung ändert.For example, you may want to generate collections deriving from the BindingList<T> instead of the List<T> class in order to bind the type to a list box and have it be automatically updated when the contents of the collection change. Legen Sie dazu die ReferencedCollectionTypes-Eigenschaft der ImportOptions-Klasse auf eine Liste mit zu verwendenden Auflistungstypen (im Weiteren als referenzierte Typen bezeichnet) fest.To do this, set the ReferencedCollectionTypes property of the ImportOptions class to a list of collection types to be used (hereafter known as the referenced types). Beim Importieren von Auflistungen wird diese Liste mit Verweisen zu Auflistungstypen durchsucht und die Auflistung mit der höchsten Übereinstimmung verwendet, falls vorhanden.When importing any collection, this list of referenced collection types is scanned and the best-matching collection is used if one is found. Es ergeben sich bei Zuordnungen nur für Typen Übereinstimmungen, die entweder die generische oder die nicht generische IDictionary-Schnittstelle implementieren, während sich bei Listen für alle unterstützten Auflistungstypen Übereinstimmungen ergeben können.Associations are matched only against types that implement either the generic or the nongeneric IDictionary interface, while lists are matched against any supported collection type.

Wenn die ReferencedCollectionTypes-Eigenschaft zum Beispiel auf eine BindingList<T> festgelegt ist, wird der people-Typ aus dem vorherigen Beispiel wie folgt generiert.For example, if the ReferencedCollectionTypes property is set to a BindingList<T>, the people type in the preceding example is generated as follows.

[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.A closed generic is considered the best match. Wenn beispielsweise die Typen BindingList(Of Integer) und ArrayList an die Auflistung der referenzierten Typen übergeben werden, werden alle Listen mit Ganzzahlen, die im Schema enthalten sind, als BindingList(Of Integer) importiert.For example, if the types BindingList(Of Integer) and ArrayList are passed to the collection of referenced types, any lists of integers found in schema are imported as a BindingList(Of Integer). Alle anderen Listen, zum Beispiel List(Of String), werden als ArrayList importiert.Any other lists, for example, a List(Of String), are imported as an ArrayList.

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.If a type that implements the generic IDictionary interface is added to the collection of referenced types, its type parameters must either be fully open or fully closed.

Duplikate sind nicht zulässig.Duplicates are not allowed. Zum Beispiel können Sie den referenzierten Typen nicht sowohl eine List(Of Integer) als auch eine Collection(Of Integer) hinzufügen.For example, you cannot add both a List(Of Integer) and a Collection(Of Integer) to the referenced types. In diesem Fall wäre es unmöglich zu bestimmen, welches Element verwendet werden soll, wenn im Schema eine Liste mit Ganzzahlen gefunden wird.That would make it impossible to determine which should be used when a list of integers is found in schema. Duplikate werden nur erkannt, wenn es einen Typ im Schema gibt, der das Duplikatproblem offenlegt.Duplicates will be detected only if there is a type in schema that exposes the duplicates problem. 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.For example, if the imported schema does not contain lists of integers, it is allowed to have both the List(Of Integer) and the Collection(Of Integer) in the referenced types collection, but neither will have any effect.

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.The referenced collection types mechanism works equally well for collections of complex types (including collections of other collections), and not just for collections of primitives.

Die ReferencedCollectionTypes Eigenschaft entspricht der /collectionType auf das Tool SvcUtil.exe wechseln.The ReferencedCollectionTypes property corresponds to the /collectionType switch on the SvcUtil.exe tool. Beachten Sie, dass mehrere Auflistungstypen verweisen die /collectionType Switch mehrmals angegeben werden muss.Note that to reference multiple collection types, the /collectionType switch must be specified multiple times. Wenn der Typ nicht in der Datei "mscorlib.dll" ist, die Assembly muss auch verwiesen werden mithilfe der /reference wechseln.If the type is not in the MsCorLib.dll, its assembly must also be referenced using the /reference switch.

Importoptionen: Verweisen auf vorhandene TypenImport Options: Referencing Existing Types

In einigen Fällen entsprechen Typen im Schema vorhandenen .NET Framework.NET Framework-Typen, und es ist nicht erforderlich, diese Typen ganz neu zu generieren.Occasionally, types in schema correspond to existing .NET Framework.NET Framework types, and there is no need to generate these types from scratch. (Dieser Abschnitt gilt nur für Typen, bei denen es sich nicht um Auflistungstypen handelt.(This section applies only to noncollection types. Auflistungstypen finden Sie im vorherigen Abschnitt.)For collection types, see the preceding section.)

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.For example, you may have a standard company-wide "Person" data contract type that you always want used when representing a person. 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.Whenever some service makes use of this type, and its schema appears in the service metadata, you may want to reuse the existing Person type when importing this schema instead of generating a new one for every service.

Übergeben Sie dazu eine Liste mit .NET Framework.NET Framework-Typen, die Sie wiederverwenden möchten, an die Auflistung, die die ReferencedTypes-Eigenschaft für die ImportOptions-Klasse zurückgibt.To do this, pass a list of .NET Framework.NET Framework types that you want to reuse into the collection the ReferencedTypes property returns on the ImportOptions class. Falls einige dieser Typen einen Datenvertragsnamen und Namespace aufweisen, der mit dem Namen und Namespace eines Schematyps übereinstimmt, wird ein Strukturvergleich durchgeführt.If any of these types have a data contract name and namespace that matches the name and namespace of a schema type, a structural comparison is performed. Wenn ermittelt wird, dass die Typen über übereinstimmende Namen und Strukturen verfügen, wird der vorhandene .NET Framework.NET Framework-Typ wiederverwendet und kein neuer Typ generiert.If it is determined that the types have both matching names and matching structures, the existing .NET Framework.NET Framework type is reused instead of generating a new one. Wenn nur der Name übereinstimmt, aber nicht die Struktur, wird eine Ausnahme ausgelöst.If only the name matches but not the structure, an exception is thrown. Beachten Sie, dass beim Verweisen auf Typen (zum Beispiel beim Hinzufügen von neuen optionalen Datenmembern) kein Spielraum für unterschiedliche Versionen besteht.Note that there is no allowance for versioning when referencing types (for example, adding new optional data members). Die Strukturen müssen genau übereinstimmen.The structures must match exactly.

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.It is legal to add multiple types with the same data contract name and namespace to the referenced types collection, as long as no schema types are imported with that name and namespace. 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.This allows you to easily add all the types in an assembly to the collection without worrying about duplicates for types that do not actually occur in schema.

Die ReferencedTypes Eigenschaft entspricht der /reference bei bestimmten Verwendungsarten des Vorgangs, der das Tool Svcutil.exe wechseln.The ReferencedTypes property corresponds to the /reference switch in certain modes of operation of the Svcutil.exe tool.

Hinweis

Bei Verwendung von Svcutil.exe oder (in Visual StudioVisual Studio) der Hinzufügen eines Dienstverweises verwenden, sind alle Typen der Datei MsCorLib.dll automatisch referenziert.When using the Svcutil.exe or (in Visual StudioVisual Studio) the Add Service Reference tools, all of the types in MsCorLib.dll are automatically referenced.

Importoptionen: Importieren von Nicht-DataContract-Schemas als IXmlSerializable-TypenImport Options: Importing Non-DataContract Schema as IXmlSerializable types

Der XsdDataContractImporter unterstützt eine beschränkte Teilmenge des Schemas.The XsdDataContractImporter supports a limited subset of the schema. Wenn nicht unterstützte Schemakonstrukte vorhanden sind (zum Beispiel XML-Attribute), schlägt der Importversuch mit einer Ausnahme fehl.If unsupported schema constructs are present (for example, XML attributes), the import attempt fails with an exception. Das Festlegen der ImportXmlType-Eigenschaft auf true erweitert jedoch den unterstützten Schemabereich.However, setting the ImportXmlType property to true extends the range of schema supported. Wenn true festgelegt ist, generiert der XsdDataContractImporter Typen, die die IXmlSerializable-Schnittstelle implementieren.When set to true, the XsdDataContractImporter generates types that implement the IXmlSerializable interface. Auf diese Weise wird der Direktzugriff auf die XML-Darstellung dieser Typen aktiviert.This enables direct access to the XML representation of these types.

EntwurfsüberlegungenDesign Considerations
  • Es kann schwierig sein, direkt mit der schwach typisierten XML-Darstellung zu arbeiten.It may be difficult to work with the weakly typed XML representation directly. Sie sollten erwägen, ein alternatives Serialisierungsmodul zu verwenden, beispielsweise XmlSerializer, um mit Schemas arbeiten zu können, die mit stark typisierten Datenverträgen nicht kompatibel sind.Consider using an alternative serialization engine, such as the XmlSerializer, to work with schema not compatible with data contracts in a strongly typed way. Weitere Informationen finden Sie unterFor more information, seeVerwenden der XmlSerializer-Klasse. Using the XmlSerializer Class.

  • Einige Schemakonstrukte können über XsdDataContractImporter nicht importiert werden. Dies ist auch dann nicht möglich, wenn die ImportXmlType-Eigenschaft auf true festgelegt ist.Some schema constructs cannot be imported by the XsdDataContractImporter even when the ImportXmlType property is set to true. Sie sollten auch hierfür erwägen, XmlSerializer zu verwenden.Again, consider using the XmlSerializer for such cases.

  • Die genauen Schemakonstrukte, die unterstützt sowohl beim ImportXmlType ist true oder false in beschriebenen Datenvertrags-Schemareferenz.The exact schema constructs that are supported both when ImportXmlType is true or false are described in Data Contract Schema Reference.

  • Schemas für generierte IXmlSerializable-Typen behalten beim Importieren und Exportieren ihre Originaltreue nicht bei.Schema for generated IXmlSerializable types do not retain fidelity when imported and exported. Wenn Sie das Schema also aus den generierten Typen exportieren und jeweils als Klasse importieren, wird nicht das Originalschema zurückgegeben.That is, exporting the schema from the generated types and importing as classes does not return the original schema.

Es ist möglich, die ImportXmlType-Option mit der oben beschriebenen ReferencedTypes-Option zu kombinieren.It is possible to combine the ImportXmlType option with the ReferencedTypes option previously described. Für Typen, die als IXmlSerializable-Implementierungen generiert werden müssen, wird beim Verwenden der ReferencedTypes-Funktion die Strukturprüfung übersprungen.For types that have to be generated as IXmlSerializable implementations, the structural check is skipped when using the ReferencedTypes feature.

Die ImportXmlType Option entspricht der /importXmlTypes auf das Tool Svcutil.exe wechseln.The ImportXmlType option corresponds to the /importXmlTypes switch on the Svcutil.exe tool.

Arbeiten mit generierten IXmlSerializable-TypenWorking with Generated IXmlSerializable Types

Die generierten IXmlSerializable-Typen enthalten ein privates Feld mit der Bezeichnung "nodesField", das ein Array mit XmlNode-Objekten zurückgibt.The generated IXmlSerializable types contain a private field, named "nodesField," that returns an array of XmlNode objects. 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.When deserializing an instance of such a type, you can access the XML data directly through this field by using the XML Document Object Model. Beim Serialisieren einer Instanz dieses Typs können Sie dieses Feld auf die gewünschten XML-Daten festlegen. Es wird dann serialisiert.When serializing an instance of this type, you can set this field to the desired XML data and it will be serialized.

Dies wird mithilfe der IXmlSerializable-Implementierung erreicht.This is accomplished through the IXmlSerializable implementation. Im generierten IXmlSerializable-Typ ruft die ReadXml-Implementierung die ReadNodes-Methode der XmlSerializableServices-Klasse auf.In the generated IXmlSerializable type, the ReadXml implementation calls the ReadNodes method of the XmlSerializableServices class. Bei der Methode handelt es sich um eine Hilfsmethode, die XML-Daten konvertiert, die über einen XmlReader für ein Array mit XmlNode-Objekten bereitgestellt werden.The method is a helper method that converts XML provided through an XmlReader to an array of XmlNode objects. Die WriteXml-Implementierung bewirkt das Gegenteil und konvertiert das Array mit den XmlNode-Objekten in eine Folge von XmlWriter-Aufrufen.The WriteXml implementation does the opposite and converts the array of XmlNode objects to a sequence of XmlWriter calls. Dies wird durch die Verwendung der WriteNodes-Methode erreicht.This is accomplished using the WriteNodes method.

Es ist möglich, den Schemaexportprozess über die generierten IXmlSerializable-Klassen auszuführen.It is possible to run the schema export process on the generated IXmlSerializable classes. Wie bereits erwähnt, erhalten Sie nicht das ursprüngliche Schema zurück.As previously stated, you will not get the original schema back. Stattdessen erhalten Sie "AnyType" standardmäßigen XSD-Typ, der ein Platzhalter für einen beliebigen XSD-Typ ist.Instead, you will get the "anyType" standard XSD type, which is a wildcard for any XSD type.

Dies erfolgt durch Anwenden der XmlSchemaProviderAttribute -Attribut auf die generierten IXmlSerializable Klassen und gibt eine Methode aufruft, die die AddDefaultSchema Methode, um den Typ "AnyType" zu generieren.This is accomplished by applying the XmlSchemaProviderAttribute attribute to the generated IXmlSerializable classes and specifying a method that calls the AddDefaultSchema method to generate the "anyType" type.

Hinweis

Der XmlSerializableServices-Typ ist nur vorhanden, um diese Funktion zu unterstützen.The XmlSerializableServices type exists solely to support this particular feature. Es ist nicht ratsam, den Typ zu einem anderen Zweck zu verwenden.It is not recommended for use for any other purpose.

Importoptionen: Erweiterte OptionenImport Options: Advanced Options

Bei den folgenden Optionen handelt es sich um erweiterte Importoptionen:The following are advanced import options:

Siehe auchSee Also

DataContractSerializer
XsdDataContractImporter
XsdDataContractExporter
ImportOptions
Datenvertrags-SchemareferenzData Contract Schema Reference
Datenvertrag-ErsatzzeichenData Contract Surrogates
Import und Export von SchemasSchema Import and Export
Exportieren von Schemas aus KlassenExporting Schemas from Classes
Datenvertrags-SchemareferenzData Contract Schema Reference