Supporto dell'associazione all'elemento Element

Articolo
02/27/2011

Questo argomento è specifico di una tecnologia legacy. Servizi Web XML e client di servizi Web XML devono essere creati attualmente tramite Windows Communication Foundation.

In .NET Framework è incluso un supporto per l'associazione all'elemento <element>.

Spiegazione

La specifica di XML Schema indica che è possibile dichiarare localmente un elemento, all'interno di una definizione di un tipo complesso, oppure globalmente come figlio dell'elemento radice <schema>. Se l'elemento viene dichiarato globalmente, è possibile farvi riferimento dall'interno di una o più definizioni di tipi complessi mediante l'attributo ref.

Nell'esempio di codice riportato di seguito viene mostrato un elemento dichiarato localmente.

<xsd:complexType name="UnitType">
  <xsd:sequence>
   <xsd:element name="name" type="xsd:string"/>
  </xsd:sequence>
</xsd:complexType>

Nell'esempio di codice riportato di seguito viene illustrato lo stesso elemento a cui viene fatto riferimento dopo averlo dichiarato globalmente.

<xsd:element name="name" type="xsd:string"/>
<xsd:complexType name="UnitType">
  <xsd:sequence>
    <xsd:element ref="name"/>
  </xsd:sequence>
</xsd:complexType>

Durante la generazione di un tipo .NET Framework da un tipo complesso di XML Schema, Xsd.exe non distingue un elemento dichiarato localmente da un riferimento a un elemento dichiarato globalmente, a meno che l'elemento globale non venga dichiarato in uno spazio dei nomi diverso da quello di destinazione dello schema.

Riferimento all'interno dello stesso spazio dei nomi

Poiché Xsd.exe non è in grado di rilevare differenze all'interno dello stesso spazio dei nomi, una conversione di round trip dallo schema XML alle classi e viceversa consente di creare elementi locali che sostituiscono i riferimenti agli elementi globali.

Se il tipo di dati dell'elemento globale a cui viene fatto riferimento include già un'associazione automatica a un tipo .NET Framework, Xsd.exe non genera un nuovo tipo corrispondente al tipo di dati. Di conseguenza, non solo non viene più fatto riferimento alla dichiarazione dell'elemento globale nello schema XML generato nel round trip, ma tale dichiarazione non viene neanche più visualizzata.

Nota:
Tutti i tipi di dati XML Schema incorporati presentano associazioni automatiche ai tipi .NET Framework. I tipi semplici definiti dallo schema, con un'unica eccezione, vengono inoltre associati ai tipi .NET Framework anziché ai tipi personalizzati. L'eccezione riguarda l'enumerazione dei tipi con associazione di stringa ed è illustrata più dettagliatamente nella documentazione relativa all'elemento <enumeration>.

Tutti i tipi di dati XML Schema incorporati presentano associazioni automatiche ai tipi .NET Framework. I tipi semplici definiti dallo schema, con un'unica eccezione, vengono inoltre associati ai tipi .NET Framework anziché ai tipi personalizzati. L'eccezione riguarda l'enumerazione dei tipi con associazione di stringa ed è illustrata più dettagliatamente nella documentazione relativa all'elemento <enumeration>.

Nota:
Per ulteriori informazioni su su come supportare i tipi semplici definiti dallo schema, vedere l'elemento <restriction> o uno degli elementi che rappresentano i facet di restrizione.

Riferimento a un altro spazio dei nomi

Se una dichiarazione globale a cui viene fatto riferimento appartiene a uno spazio dei nomi differente, Xsd.exe specifica lo spazio dei nomi utilizzando la proprietà Namespace di un attributo XmlElementAttribute applicato al campo generato. Per questo particolare elemento, lo spazio dei nomi specificato mediante la proprietà Namespace esegue l'override dello spazio dei nomi specificato a livello di classe utilizzando l'attributo XmlTypeAttribute e, facoltativamente, XmlRootAttribute come mostrato nell'esempio seguente.

[System.Xml.Serialization.XmlElementAttribute(Namespace="http://example.org/elem")]
public string Text;

Spazi dei nomi aggiuntivi vengono importati in una definizione XML Schema mediante l'elemento <import>.

Creazione di dichiarazioni di elementi globali

Durante la generazione di un documento XML Schema da un set di classi in un assembly, Xsd.exe produce una dichiarazione <element>< globale per ogni definizione >complexType< o >simpleType prodotta da un tipo definito nell'assembly.

Nel primo esempio viene illustrato come Xsd.exe elabora un elemento globale quando tale elemento è definito nello stesso spazio dei nomi di destinazione che contiene un riferimento a esso.

Documento XLM Schema di input.

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
      xmlns="http://example.org/" targetNamespace="http://example.org/" elementFormDefault="qualified">
  <xsd:element name="Text" type="xsd:normalizedString"/>
  <xsd:complexType name="Branch">
    <xsd:sequence>
      <xsd:element name="children" type="xsd:token" minOccurs="0" maxOccurs="unbounded" />
      <xsd:element ref="Text" />
    </xsd:sequence>
    <xsd:attribute name="key" type="xsd:token"/>
  </xsd:complexType>
  <xsd:element name="branch" type="Branch"/>
</xsd:schema>

Classe C# generata dal documento XML Schema precedente.

[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlRootAttribute("branch", Namespace="http://example.org/", IsNullable=false)]
public class Branch {
        
    [System.Xml.Serialization.XmlElementAttribute("children", DataType="token")]
    public string[] children;
        
    [System.Xml.Serialization.XmlElementAttribute(DataType="normalizedString")]
    public string Text;
        
    [System.Xml.Serialization.XmlAttributeAttribute(DataType="token")]
    public string key;
}

Documento XML Schema generato da un assembly compilato dal codice sorgente C# precedente.

<xs:schema xmlns:tns="http://example.org/" elementFormDefault="qualified" targetNamespace="http://example.org/" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="branch" type="tns:Branch" />
  <xs:complexType name="Branch">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="unbounded" name="children" type="xs:token" />
      <xs:element minOccurs="0" maxOccurs="1" name="Text" type="xs:normalizedString" />
    </xs:sequence>
    <xs:attribute name="key" type="xs:token" />
  </xs:complexType>
</xs:schema>

Nello schema XML generato precedentemente l'elemento Text, in origine dichiarato globalmente, è stato impostato come elemento locale.

Nel secondo esempio viene illustrata la modalità di elaborazione mediante Xsd.exe di un riferimento a un elemento globale quando tale elemento è definito in uno spazio dei nomi separato. Nell'esempio viene utilizzato l'elemento <import> per importare un secondo spazio dei nomi disponibile in un file XSD separato. Per specificare la posizione del file con estensione xsd importato, non viene utilizzato l'attributo schemaLocation dell'elemento <import>. Per Xsd.exe il file viene invece specificato come argomento aggiuntivo della riga di comando.

Documento XML Schema di primo livello utilizzato come input.

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified"
      xmlns="http://example.org/" targetNamespace="http://example.org/" xmlns:elem="http://example.org/elem">
  <xsd:import  namespace="http://example.org/elem" />
  <xsd:complexType name="Branch">
    <xsd:sequence>
      <xsd:element name="children" type="xsd:token" minOccurs="0" maxOccurs="unbounded" />
      <xsd:element ref="elem:Text" />
    </xsd:sequence>
    <xsd:attribute name="key" type="xsd:token"/>
  </xsd:complexType>
  <xsd:element name="branch" type="Branch"/>
</xsd:schema>

Documento XML Schema importato utilizzato come input.

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" 
      xmlns="http://example.org/elem" targetNamespace="http://example.org/elem">
  <xsd:element name="Text" type="xsd:normalizedString"/>
</xsd:schema>

Classe C# generata dai due documenti XML Schema precedenti.

[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlRootAttribute("branch", Namespace="http://example.org/", IsNullable=false)]
public class Branch {
        
    [System.Xml.Serialization.XmlElementAttribute("children", DataType="token")]
    public string[] children;
        
    [System.Xml.Serialization.XmlElementAttribute(Namespace="http://example.org/elem", DataType="normalizedString")]
    public string Text;
        
    [System.Xml.Serialization.XmlAttributeAttribute(DataType="token")]
    public string key;
}

Documento XML Schema di primo livello generato da un assembly compilato dal codice sorgente C# precedente.

<xs:schema xmlns:tns="http://example.org/" elementFormDefault="qualified" targetNamespace="http://example.org/" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:import namespace="http://example.org/elem" />
  <xs:element name="branch" type="tns:Branch" />
  <xs:complexType name="Branch">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="unbounded" name="children" type="xs:token" />
      <xs:element minOccurs="0" maxOccurs="1" xmlns:q1="http://example.org/elem" ref="q1:Text" />
    </xs:sequence>
    <xs:attribute name="key" type="xs:token" />
  </xs:complexType>
</xs:schema>

Documento XML Schema importato generato da un assembly compilato dal codice sorgente C# precedente.

<xs:schema xmlns:tns="http://example.org/elem" elementFormDefault="qualified" targetNamespace="http://example.org/elem" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="Text" type="xs:normalizedString" />
</xs:schema>

Attributo abstract

Diversamente da un elemento locale, una dichiarazione di elemento globale può contenere un attributo abstract.

Dichiarare un elemento astratto (abstract="true") per imporne la sostituzione mediante un gruppo di sostituzione. Se l'elemento non è astratto, la sostituzione è facoltativa.

L'elemento globale sostituito viene definito elemento Head. Quando una dichiarazione di elemento locale fa riferimento all'elemento Head mediante l'attributo ref, è possibile utilizzare qualsiasi elemento sostitutivo globale al suo posto. Per ulteriori informazioni, vedere l'attributo substitutionGroup.

Se gli elementi sostitutivi appartengono a tipi di dati derivati e se l'elemento Head stesso (anziché la definizione <complexType> per il relativo tipo dichiarato astratto) viene dichiarato astratto, è possibile utilizzare il tipo base in altri punti di un documento di istanza XML, ma non nel punto in cui viene eseguita la sostituzione.

Durante la generazione di codice sorgente da un documento XML Schema, viene prodotto un tipo corrispondente al tipo di dati dell'elemento Head. Tale tipo include un campo denominato Item, e viene applicato un attributo XmlElementAttribute per ogni elemento sostitutivo. Ciascun attributo identifica il nome e il tipo, se l'elemento sostitutivo dispone di un tipo di dati derivato. Se gli elementi sostitutivi utilizzano lo stesso tipo di dati dell'elemento Head, sarà necessario applicare anche un attributo XmlChoiceIdentifierAttribute. Per ulteriori informazioni, vedere l'elemento <choice>.

Nell'esempio di codice riportato di seguito viene illustrato un campo di esempio, Item, generato da un riferimento a un elemento Head astratto.

[System.Xml.Serialization.XmlElementAttribute("derivedAInstance", typeof(DerivedTypeA))]
[System.Xml.Serialization.XmlElementAttribute("derivedBInstance", typeof(DerivedTypeB))]
public MyBaseType Item;

Se si utilizzano elementi sostitutivi appartenenti a tipi di dati derivati, la serializzazione XML funzionerà solo quando un'istanza di uno dei tipi derivati sarà stata assegnata al campo. Se è stata assegnata un'istanza del tipo base corrispondente all'elemento Head, la classe XmlSerializer restituisce un errore.

In una conversione inversa Xsd.exe produce un elemento <choice> che contiene un elemento <element> per ogni elemento sostitutivo e nessun <element> che rappresenta l'elemento Head. Gli elementi vengono definiti indipendentemente all'interno della definizione di tipo complesso, senza specificare riferimenti ref.

Nota:
In una dichiarazione <element> locale contenente un attributo ref che specifica un elemento Head astratto, l'attributo maxOccurs viene ignorato.

Nota:
Si consideri la seguente dichiarazione di un elemento Head di tipo `MyBaseType`.

<xsd:element ref="baseInstance" minOccurs="0" maxOccurs="unbounded" />

Nota:
Per la dichiarazione precedente, Xsd.exe produce ancora il campo seguente con omissione degli attributi.

public MyBaseType Item;

Nota:
Se tutti gli elementi dichiarati globalmente nello schema XML di input sono astratti, non sarà possibile generare classi.

Esempio: attributo abstract

Documento XLM Schema di input.

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
      targetNamespace="http://example.org/" xmlns="http://example.org/" elementFormDefault="qualified">
  <xsd:element name="baseInstance" type="MyBaseType" abstract="true"/>

  <xsd:complexType name="MyBaseType">
    <xsd:sequence>
      <xsd:element name="Field1" type="xsd:string"/>
      <xsd:element name="Field2" type="xsd:string"/>
    </xsd:sequence>
  </xsd:complexType>

  <xsd:element name="derivedAInstance" type="DerivedTypeA" substitutionGroup="baseInstance" />
  <xsd:complexType name="DerivedTypeA">
    <xsd:complexContent>
      <xsd:extension base="MyBaseType">
         <xsd:attribute name="ExtraInfoForA" type="xsd:string"/>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="derivedBInstance" type="DerivedTypeB" substitutionGroup="baseInstance" />
  <xsd:complexType name="DerivedTypeB">
    <xsd:complexContent>
      <xsd:extension base="MyBaseType">
         <xsd:attribute name="ExtraInfoForB" type="xsd:string"/>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="myThings" type="MyThingsType" />
  <xsd:complexType name="MyThingsType">
    <xsd:sequence>
      <xsd:element ref="baseInstance" />
    </xsd:sequence>
  </xsd:complexType>
</xsd:schema>

Classi C# generate dal documento XML Schema precedente.

[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlRootAttribute("derivedAInstance", Namespace="http://example.org/", IsNullable=false)]
public class DerivedTypeA : MyBaseType {
        
    [System.Xml.Serialization.XmlAttributeAttribute()]
    public string ExtraInfoForA;
}
    
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlIncludeAttribute(typeof(DerivedTypeA))]
[System.Xml.Serialization.XmlIncludeAttribute(typeof(DerivedTypeB))]
public class MyBaseType {
    public string Field1;
        
    public string Field2;
}
    
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlRootAttribute("derivedBInstance", Namespace="http://example.org/", IsNullable=false)]
public class DerivedTypeB : MyBaseType {
        
    [System.Xml.Serialization.XmlAttributeAttribute()]
    public string ExtraInfoForB;
}
    
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlRootAttribute("myThings", Namespace="http://example.org/", IsNullable=false)]
public class MyThingsType {       
    [System.Xml.Serialization.XmlElementAttribute("derivedAInstance", typeof(DerivedTypeA))]
    [System.Xml.Serialization.XmlElementAttribute("derivedBInstance", typeof(DerivedTypeB))]
    public MyBaseType Item;
}

Documento XML Schema generato da un assembly compilato dal codice sorgente C# precedente.

<xs:schema xmlns:tns="http://example.org/" elementFormDefault="qualified" targetNamespace="http://example.org/" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:complexType name="MyBaseType">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="1" name="Field1" type="xs:string" />
      <xs:element minOccurs="0" maxOccurs="1" name="Field2" type="xs:string" />
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="DerivedTypeA">
    <xs:complexContent mixed="false">
      <xs:extension base="tns:MyBaseType">
        <xs:attribute name="ExtraInfoForA" type="xs:string" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="DerivedTypeB">
    <xs:complexContent mixed="false">
      <xs:extension base="tns:MyBaseType">
        <xs:attribute name="ExtraInfoForB" type="xs:string" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="derivedAInstance" type="tns:DerivedTypeA" />
  <xs:element name="derivedBInstance" type="tns:DerivedTypeB" />
  <xs:element name="myThings" type="tns:MyThingsType" />
  <xs:complexType name="MyThingsType">
    <xs:sequence>
      <xs:choice minOccurs="1" maxOccurs="1">
        <xs:element minOccurs="0" maxOccurs="1" name="derivedAInstance" type="tns:DerivedTypeA" />
        <xs:element minOccurs="0" maxOccurs="1" name="derivedBInstance" type="tns:DerivedTypeB" />
      </xs:choice>
    </xs:sequence>
  </xs:complexType>
</xs:schema>

Attributo substitutionGroup

Lo strumento Xsd.exe riconosce i gruppi di sostituzione solo se l'elemento sostituito viene dichiarato come astratto. Vedere la sezione precedente, Abstract Attribute. Successivamente, in una conversione inversa verrà prodotto un elemento <choice> contenente un elemento <element> per ognuno dei sostituti.

Attributo substitutionGroup: concetti di base

L'attributo substitutionGroup può essere visualizzato con un elemento dichiarato globalmente per consentire a quest'ultimo di sostituire un altro elemento dichiarato globalmente in un documento di istanza XML. Il valore dell'attributo è il nome dell'elemento sostituito, denominato Head. La sostituzione effettiva può essere eseguita in un elemento <element> all'interno di una definizione di un tipo complesso, in cui viene fatto riferimento all'elemento Head mediante l'attributo ref. Gli elementi dichiarati con l'attributo substitutionGroup devono essere dello stesso tipo di dati dell'elemento Head o di un tipo derivato.

Un gruppo di sostituzione viene utilizzato per consentire la visualizzazione di elementi con nomi differenti, e facoltativamente tipi differenti con lo stesso tipo base, in una posizione specificata in un documento di istanza.

I gruppi di sostituzione nidificati non sono supportati. Se pertanto un elemento agisce come elemento Head in un gruppo di sostituzione, non può essere l'elemento sostituito in un altro gruppo di sostituzione. Di seguito è riportato un esempio:

<xs:element name="Animal" abstract="true"/>
<xs:element name="Mammal" abstract="true" 
    substitutionGroup="tns:Animal"/>
<xs:element name="Dog" type="xs:string" 
    substitutionGroup="tns:Mammal"/>

Questo schema non è supportato perché Mammal agisce sia come elemento Head (per Dog) che come elemento sostituito (per Animal). Se viene rilevato uno schema di questo tipo, non viene generata una classe XmlElementAttribute per Mammal. Dog inoltre non si troverà dove è previsto l'elemento Animal. È tuttavia possibile aggiungere manualmente questo schema per garantire il funzionamento di questo caso, come illustrato nell'esempio riportato di seguito.

public class PetShop 
{
    private object Animal;
    
    // Apply the XmlElementAttribute to the generated property.
    [System.Xml.Serialization.XmlElementAttribute("Mammal"), 
     System.Xml.Serialization.XmlElementAttribute("Dog")]
    public object Animal {
        get {
            return this.Animal;
        }
        set {
            this.Animal = value;
        }
    }
}

Attributo substitutionGroup: elemento Head concreto

Se l'elemento Head non è astratto, Xsd.exe accetta ogni riferimento ref a tale elemento e crea un campo del tipo corrispondente al tipo di dati XML dell'elemento Head o a una matrice di quel tipo, a seconda del valore dell'attributo maxOccurs dell'elemento di riferimento. Tutti i riferimenti al gruppo di sostituzione andranno persi.

Sebbene sia possibile assegnare un oggetto di un tipo derivato a tale campo consentendone la serializzazione mediante la classe XmlSerializer, tale comportamento si verifica all'esterno della sostituzione con tipi derivati. Non viene utilizzato alcun nome di elemento sostitutivo.

Attributo substitutionGroup: elemento Head astratto

Se l'elemento Head è astratto, viene prodotto un campo di un tipo corrispondente al tipo di dati di tale elemento. Al campo viene assegnato il nome Item e viene applicato un attributo XmlElementAttribute per ogni elemento sostitutivo. Ciascun attributo identifica il nome e il tipo, se l'elemento sostitutivo dispone di un tipo di dati derivato. Se gli elementi sostitutivi utilizzano lo stesso tipo di dati dell'elemento Head, sarà necessario applicare anche un attributo XmlChoiceIdentifierAttribute. Vedere l'elemento <choice>.

Di seguito è riportato un campo di esempio generato da un riferimento a un elemento Head astratto.

[System.Xml.Serialization.XmlElementAttribute("derivedAInstance", typeof(DerivedTypeA))]
[System.Xml.Serialization.XmlElementAttribute("derivedBInstance", typeof(DerivedTypeB))]
public MyBaseType Item;

Se vengono utilizzati tipi derivati, la serializzazione XML funzionerà solo quando un'istanza di uno dei tipi derivati sarà stata assegnata al campo. Se è stata assegnata un'istanza del tipo base corrispondente all'elemento Head, la classe XmlSerializer restituisce un errore.

In una conversione inversa da questo costrutto viene prodotto un elemento <choice> contenente un elemento <element> per ogni elemento sostitutivo e non per l'elemento Head. Gli elementi vengono definiti indipendentemente all'interno della definizione di tipo complesso, senza specificare riferimenti ref.

maxOccurs attribute. In una dichiarazione <element> locale contenente un attributo ref che specifica un elemento Head astratto, l'attributo maxOccurs viene ignorato.

Si consideri la dichiarazione seguente che fa riferimento a un elemento Head di tipo MyBaseType.

<xsd:element ref="baseInstance" minOccurs="0" maxOccurs="unbounded" />

Per la dichiarazione precedente, viene prodotto ancora il campo seguente con omissione degli attributi.

public MyBaseType Item;

Esempio: attributo substitutionGroup

Documento XLM Schema di input.

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
      targetNamespace="http://example.org/" xmlns="http://example.org/" elementFormDefault="qualified">
  <xsd:element name="baseInstance" type="MyBaseType" abstract="true"/>

  <xsd:complexType name="MyBaseType">
    <xsd:sequence>
      <xsd:element name="Field1" type="xsd:string"/>
      <xsd:element name="Field2" type="xsd:string"/>
    </xsd:sequence>
  </xsd:complexType>

  <xsd:element name="derivedAInstance" type="DerivedTypeA" substitutionGroup="baseInstance" />
  <xsd:complexType name="DerivedTypeA">
    <xsd:complexContent>
      <xsd:extension base="MyBaseType">
         <xsd:attribute name="ExtraInfoForA" type="xsd:string"/>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="derivedBInstance" type="DerivedTypeB" substitutionGroup="baseInstance" />
  <xsd:complexType name="DerivedTypeB">
    <xsd:complexContent>
      <xsd:extension base="MyBaseType">
         <xsd:attribute name="ExtraInfoForB" type="xsd:string"/>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="myThings" type="MyThingsType" />
  <xsd:complexType name="MyThingsType">
    <xsd:sequence>
      <xsd:element ref="baseInstance" />
    </xsd:sequence>
  </xsd:complexType>
</xsd:schema>

Classi C# generate dal documento XML Schema precedente.

[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlRootAttribute("derivedAInstance", Namespace="http://example.org/", IsNullable=false)]
public class DerivedTypeA : MyBaseType {
        
    [System.Xml.Serialization.XmlAttributeAttribute()]
    public string ExtraInfoForA;
}
    
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlIncludeAttribute(typeof(DerivedTypeA))]
[System.Xml.Serialization.XmlIncludeAttribute(typeof(DerivedTypeB))]
public class MyBaseType {
    public string Field1;
        
    public string Field2;
}
    
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlRootAttribute("derivedBInstance", Namespace="http://example.org/", IsNullable=false)]
public class DerivedTypeB : MyBaseType {
        
    [System.Xml.Serialization.XmlAttributeAttribute()]
    public string ExtraInfoForB;
}
    
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlRootAttribute("myThings", Namespace="http://example.org/", IsNullable=false)]
public class MyThingsType {       
    [System.Xml.Serialization.XmlElementAttribute("derivedAInstance", typeof(DerivedTypeA))]
    [System.Xml.Serialization.XmlElementAttribute("derivedBInstance", typeof(DerivedTypeB))]
    public MyBaseType Item;
}

Documento XML Schema generato da un assembly compilato dal codice sorgente C# precedente.

<xs:schema xmlns:tns="http://example.org/" elementFormDefault="qualified" targetNamespace="http://example.org/" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:complexType name="MyBaseType">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="1" name="Field1" type="xs:string" />
      <xs:element minOccurs="0" maxOccurs="1" name="Field2" type="xs:string" />
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="DerivedTypeA">
    <xs:complexContent mixed="false">
      <xs:extension base="tns:MyBaseType">
        <xs:attribute name="ExtraInfoForA" type="xs:string" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="DerivedTypeB">
    <xs:complexContent mixed="false">
      <xs:extension base="tns:MyBaseType">
        <xs:attribute name="ExtraInfoForB" type="xs:string" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="derivedAInstance" type="tns:DerivedTypeA" />
  <xs:element name="derivedBInstance" type="tns:DerivedTypeB" />
  <xs:element name="myThings" type="tns:MyThingsType" />
  <xs:complexType name="MyThingsType">
    <xs:sequence>
      <xs:choice minOccurs="1" maxOccurs="1">
        <xs:element minOccurs="0" maxOccurs="1" name="derivedAInstance" type="tns:DerivedTypeA" />
        <xs:element minOccurs="0" maxOccurs="1" name="derivedBInstance" type="tns:DerivedTypeB" />
      </xs:choice>
    </xs:sequence>
  </xs:complexType>
</xs:schema>

Attributi possibili	Supporto per l'associazione
abstract	L'utilità Xsd.exe esegue l'associazione dei gruppi di sostituzione utilizzando dichiarazioni <element> astratte, ma produce elementi <choice> in una conversione inversa. Vedere la sezione precedente, Attributo Abstract.
block	È possibile utilizzare l'attributo block per impedire l'utilizzo delle dichiarazioni di elementi come elementi Head dei gruppi di sostituzione, ovvero gli elementi che vengono sostituiti da membri di gruppi. Lo strumento Xsd.exe ignora l'attributo block, nonché l'attributo blockDefault dell'elemento Supporto dell'associazione all'elemento Schema.
default	L'attributo default fornisce un valore predefinito da utilizzare se l'elemento è vuoto in un documento di istanza. Se l'elemento non viene visualizzato, non viene compilato. Quando genera codice sorgente da un documento XML Schema, lo strumento Xsd.exe accetta ogni campo corrispondente a un elemento con un valore predefinito e applica un attributo System.ComponentModel.DefaultValueAttribute, passando il valore predefinito come argomento. Inoltre, Xsd.exe inizializza il campo in modo statico sul valore predefinito, come nell'esempio seguente. `[System.ComponentModel.DefaultValueAttribute(-1)] public int age = -1;` Durante la generazione di un elemento <element> da un membro di classe con un tipo di valore .NET Framework, Xsd.exe utilizza l'attributo DefaultValue come input per l'impostazione dell'attributo minOccurs. Se viene rilevato un attributo DefaultValue applicato a tale membro, viene prodotto il valore `0` per l'attributo minOccurs dell'elemento, a indicare che non è necessario visualizzare l'elemento in un documento di istanza XML valido. L'attributo predefinito viene ignorato per le matrici (elementi in cui maxOccurs è maggiore di `1`). Vedere l'attributo Supporto dell'associazione all'attributo default.
final	È possibile utilizzare l'attributo final per impedire l'utilizzo delle dichiarazioni di elementi come elementi Head dei gruppi di sostituzione, ovvero gli elementi che vengono sostituiti da membri di gruppi. Xsd.exe ignora l'attributo final, nonché l'attributo finalDefault dell'elemento <schema>.
fixed	L'attributo fixed fornisce un valore fisso per l'elemento in un documento di istanza. Quando si genera codice sorgente da un documento XML Schema, Xsd.exe accetta ogni campo corrispondente a un elemento con un valore fisso e genera un inizializzatore static per il campo, come nell'esempio che segue. `public int age = -1;` L'attributo fisso viene ignorato per le matrici (elementi in cui maxOccurs è maggiore di `1`).
form	Lo strumento Xsd.exe considera l'attributo XML form dell'elemento <element> equivalente alla proprietà Form di XmlElementAttribute. L'infrastruttura di serializzazione XML di .NET Framework riconosce un valore predefinito differente, ovvero `qualified`. Se una dichiarazione <element> in uno schema XML specifica `form="unqualified"`, Xsd.exe genera un attributo XmlElement per il campo corrispondente e passa all'attributo il parametro `Form=XmlSchemaForm.Unqualified`. Vedere l'attributo form.
id	L'utilità Xsd.exe ignora l'attributo id che fornisce un identificatore univoco, mentre riconosce l'attributo name.
maxOccurs	Durante la generazione di classi da un documento XSD, Xsd.exe interpreta l'attributo maxOccurs dell'elemento <element> in base ai valori possibili seguenti: `1`: Xsd.exe produce un campo del tipo corrispondente al tipo di dati dell'elemento. `0`: Xsd.exe non riesce a elaborare il valore `0` e lo considera al pari del valore predefinito `1`. `unbounded`: Xsd.exe produce un campo che rappresenta una matrice del tipo corrispondente al tipo di dati dell'elemento. Qualsiasi numero intero maggiore di 1: come per il valore `unbounded`, Xsd.exe produce un campo che rappresenta una matrice del tipo corrispondente al tipo di dati dell'elemento. È possibile imporre un valore maggiore di 1 convalidando un documento XML con la classe XmlValidatingReader in base a un documento XML Schema rappresentato dal modello SOM. Durante la generazione di un documento XML Schema da un set di classi di un assembly, Xsd.exe inverte le conversioni precedenti, producendo un valore maxOccurs pari a `1` da una singola istanza e un valore maxOccurs pari a `unbounded` da una matrice. Xsd.exe associa un valore maxOccurs pari a `unbounded` a una matrice e un valore maxOccurs pari a `1` all'elemento padre designato di una matrice, se disponibile. Per ulteriori informazioni su come trattare l'elemento maxOccurs per le associazioni delle matrici, inclusa la designazione di un elemento padre aggiuntivo, vedere l'attributo Supporto dell'associazione all'attributo MaxOccurs.
minOccurs	Per l'elemento <element>, Xsd.exe controlla il valore dell'attributo minOccurs solo se il valore dell'attributo Supporto dell'associazione all'attributo MaxOccurs non impone un campo matrice. Il valore viene quindi interpretato o prodotto in base a diversi fattori, a partire dalla presenza o meno di un tipo di riferimento o di valore nel campo corrispondente. Vedere l'attributo Supporto dell'associazione all'attributo MinOccurs.
name	Per la generazione del codice sorgente da un documento XSD, il valore dell'attributo name specifica il nome del campo della classe pubblica che rappresenta l'elemento. Se l'elemento <element> contiene una definizione <complexType> anonima, il nome diventa il nome della classe corrispondente al tipo complesso. Non viene eseguito alcun tentativo di modifica della combinazione di lettere maiuscole/minuscole al fine di rispettare le convenzioni di codifica. Se, ad esempio, l'attributo name di un <element> contenente una definizione di un tipo complesso anonimo ha il valore `testInfo`, alla classe risultante verrà assegnato il nome `testInfo`, anziché il nome `TestInfo` con lettere maiuscole. Se un nome è in conflitto con una parola chiave riservata, il nome risultante sarà seguito dal simbolo @. Quando Xsd.exe genera una dichiarazione <element> dal campo di una classe pubblica, utilizza il nome del campo per il valore dell'attributo name. È possibile specificare un nome alternativo, ovvero il valore dell'attributo name, mediante le proprietà di attributo seguenti: System.Xml.Serialization.XmlElementAttribute.ElementName System.Xml.Serialization.XmlArrayAttribute.ElementName: modifica il nome dell'elemento XML padre della matrice. System.Xml.Serialization.XmlArrayItemAttribute.ElementName: modifica i nomi degli elementi figlio sequenziali che corrispondono alle voci di matrice. System.Xml.Serialization.XmlRootAttribute.ElementName Vedere l'attributo Supporto dell'associazione all'attributo name.
nillable	Lo strumento Xsd.exe considera l'attributo nillable equivalente alla proprietà IsNullable di determinati attributi relativi alla serializzazione XML applicati ai tipi di riferimento. Per i tipi di valore, il valore nillable di true determina la generazione dei tipi nullable. Vedere l'attributo nillable. L'attributo nillable è presente solo nell'elemento <element>.
ref	Durante la generazione di un tipo .NET Framework da un tipo complesso di XML Schema, Xsd.exe non distingue un elemento dichiarato localmente da un riferimento a un elemento dichiarato globalmente, a meno che l'elemento globale non venga dichiarato in uno spazio dei nomi diverso da quello di destinazione dello schema. Vedere le sezioni Riferimento all'interno dello stesso spazio dei nomi e Riferimento a un altro spazio dei nomi.
substitutionGroup	Lo strumento Xsd.exe riconosce i gruppi di sostituzione solo se l'elemento sostituito viene dichiarato come astratto. Successivamente, in una conversione inversa verrà prodotto un elemento <choice> contenente un elemento <element> per ognuno dei sostituti. Vedere la sezione precedente Attributo SubstitutionGroup.
type	Lo strumento Xsd.exe associa i tipi di dati cui si fa riferimento mediante l'attributo type delle dichiarazioni <element> e <attribute> ai tipi .NET Framework. Xsd.exe non genera un tipo .NET Framework per un tipo di dati dello schema XML, a meno che non sia possibile far risalire il tipo di dati a una dichiarazione di elemento globale che fa riferimento a un tipo di dati, possibilmente diverso, mediante l'attributo type.

Elementi padre possibili: <all>, <choice>, <schema>, <sequence>

Elementi figlio possibili: <annotation>, <complexType>, <key>, <keyref>, <simpleType>, <unique>

Vedere anche

Riferimento

XmlSchemaElement

Condividi tramite

Supporto dell'associazione all'elemento Element

Spiegazione

Riferimento all'interno dello stesso spazio dei nomi

Riferimento a un altro spazio dei nomi

Creazione di dichiarazioni di elementi globali

Attributo abstract

Esempio: attributo abstract

Attributo substitutionGroup

Attributo substitutionGroup: concetti di base

Attributo substitutionGroup: elemento Head concreto

Attributo substitutionGroup: elemento Head astratto

Esempio: attributo substitutionGroup

Vedere anche

Riferimento

Risorse aggiuntive