Compatibilidad con enlaces del elemento Element

Artículo
02/27/2011

Este tema es específico de una tecnología heredada. Ahora, los servicios Web XML y los clientes de servicios Web XML deben crearse con Windows Communication Foundation.

.NET Framework proporciona compatibilidad con enlaces para el elemento <element>.

Explicación

La especificación de esquemas XML indica que un elemento puede declararse localmente, dentro de una definición de tipo complejo, o globalmente, como elemento secundario del elemento raíz <schema>. Si el elemento se declara globalmente, puede hacerse referencia al mismo desde una o varias definiciones de tipos complejos, mediante el atributo ref.

En el siguiente ejemplo de código se muestra un elemento declarado localmente.

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

En el siguiente ejemplo de código se muestra el mismo elemento declarado globalmente y, a continuación, se hace referencia al mismo.

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

Cuando se genera un tipo de .NET Framework a partir de un tipo complejo de esquema XML, Xsd.exe no diferencia un elemento declarado localmente de una referencia a un elemento declarado globalmente a menos que el elemento global se declare en un espacio de nombres distinto del espacio de nombres de destino del esquema.

Referencia en el mismo espacio de nombres

Como Xsd.exe no es capaz de diferenciar dentro del mismo espacio de nombres, una operación de traducción de ida y vuelta del esquema en clases y viceversa crea elementos locales que sustituyen todas las referencias a elementos globales.

Si el tipo de datos del elemento global al que se hace referencia ya dispone de un enlace automático a un tipo de .NET Framework, Xsd.exe no genera ningún tipo nuevo correspondiente al tipo de datos. Como consecuencia, no solo deja de hacerse referencia a la declaración del elemento global en el esquema XML generado en la operación de ida y vuelta, sino que también deja de aparecer allí.

Nota:
Todos los tipos de datos de esquemas XML integrados disponen de enlaces automáticos a tipos de .NET Framework. Además, los tipos simples definidos en esquemas, con una única excepción, se enlazan a tipos de .NET Framework en lugar de a tipos personalizados. La única excepción que existe es la enumeración de tipos de enlace de cadenas; esta excepción se explica más detalladamente en la documentación del elemento <enumeration>.

Todos los tipos de datos de esquemas XML integrados disponen de enlaces automáticos a tipos de .NET Framework. Además, los tipos simples definidos en esquemas, con una única excepción, se enlazan a tipos de .NET Framework en lugar de a tipos personalizados. La única excepción que existe es la enumeración de tipos de enlace de cadenas; esta excepción se explica más detalladamente en la documentación del elemento <enumeration>.

Nota:
Para la compatibilidad de Para obtener más información sobre con tipos simples definidos en esquemas, vea el elemento <restriction> o cualquiera de los elementos que representan facetas de restricción.

Referencia a otro espacio de nombres

Si una declaración global a la que se hace referencia pertenece a un espacio de nombres distinto, Xsd.exe especifica el espacio de nombres utilizando la propiedad Namespace de un atributo XmlElementAttribute que se aplica a un campo general. Para ese elemento en particular, el espacio de nombres especificado a través de la propiedad Namespace reemplaza al espacio de nombres especificado en el nivel de clase utilizando el atributo XmlTypeAttribute y, opcionalmente, XmlRootAttribute como se muestra en el siguiente ejemplo.

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

Los espacios de nombres adicionales se importan en una definición de esquema XML utilizando el elemento <import>.

Creación de declaraciones de elementos globales

Cuando se genera un documento de esquemas XML a partir de un conjunto de clases de un ensamblado, Xsd.exe genera una declaración global <element> para cada definición de <complexType> o <simpleType> que se genera a partir de un tipo definido en el ensamblado.

En el primer ejemplo se muestra la forma en que Xsd.exe procesa un elemento global cuando dicho elemento se define en el mismo espacio de nombres de destino que contiene una referencia al mismo.

Documento de esquema XML de entrada.

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

Clase de C# generada a partir del documento de esquema XML anterior.

[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;
}

El documento del esquema XML que se ha generado a partir de un ensamblado compilado con el anterior código fuente C#.

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

En el esquema XML generado anteriormente, el elemento Text, que en su origen se ha declarado globalmente, se ha convertido en un elemento local.

En este segundo ejemplo se muestra cómo Xsd.exe procesa una referencia a un elemento global cuando dicho elemento está definido en un espacio de nombres independiente. En este ejemplo se utiliza el elemento <import> para importar un segundo espacio de nombres ubicado en un archivo XSD independiente. (El atributo schemaLocation del elemento <import>. En su lugar, con respecto a Xsd.exe, el archivo se especifica como argumento de línea de comandos adicional).

Documento de esquema XML de nivel superior usado como entrada.

<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 de esquema XML importado usado como entrada.

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

Clase de C# generada a partir de los dos documentos de esquema XML anteriores.

[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;
}

El documento de esquema XML de nivel superior que se ha generado a partir de un ensamblado compilado con el anterior código fuente C#.

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

El documento de esquema XML importado que se ha generado a partir de un ensamblado compilado con el anterior código fuente C#.

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

Atributo Abstract

Una declaración de elemento global puede disponer de un atributo abstract; un elemento local, no.

Declare un elemento abstracto (abstract="true") para forzar su sustitución usando un grupo de sustitución; si el elemento no es abstracto, la sustitución será opcional.

El elemento global que se va a sustituir se denomina elemento de encabezado. Siempre que en la declaración de un elemento local se haga referencia al elemento de encabezado usando el atributo ref, podrá utilizarse cualquier elemento global sustituto en su lugar. Para obtener más información, vea el atributo substitutionGroup.

Si los elementos sustitutos pertenecen a tipos de datos derivados y si el propio elemento de encabezado se declara como abstracto (en lugar de declararse como abstracta la definición <complexType> de su tipo), el tipo base podrá utilizarse en cualquier otro lugar de un documento XML de instancia, aunque no pueda utilizarse en la posición donde tenga lugar la sustitución.

Cuando se genera código fuente a partir de un documento de esquemas XML, Xsd.exe se genera un tipo correspondiente al tipo de datos del elemento de encabezado. Este tipo incluye un campo denominado Item. Xsd.exe aplica a este campo un atributo XmlElementAttribute para cada uno de los sustitutos. Cada atributo identifica el nombre y, si el elemento sustituto presenta un tipo de datos derivado, el tipo. Si los elementos sustitutos utilizan el mismo tipo de datos que el encabezado, también debe aplicarse un XmlChoiceIdentifierAttribute. Para obtener más información, vea el elemento <choice>.

En el siguiente ejemplo de código se muestra un campo de ejemplo, Item, generado a partir de una referencia a un elemento de encabezado abstracto.

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

Si se utilizan elementos sustitutos pertenecientes a tipos de datos derivados, la serialización XML solo funcionará cuando se haya asignado al campo una instancia de uno de los tipos derivados. La clase XmlSerializer producirá errores si se ha asignado una instancia del tipo base correspondiente al elemento de encabezado.

En una traducción inversa, Xsd.exe genera un elemento <choice> que contiene un elemento <element> por cada elemento sustituto y que no contiene ningún elemento <element> que represente el elemento de encabezado. Los elementos se definen de forma independiente dentro de la definición de tipo complejo; no se utiliza ninguna referencia ref.

Nota:
En una declaración <element> local con un atributo ref que especifica un elemento de encabezado abstracto, Xsd.exe omite el atributomaxOccurs.

Nota:
Considere la siguiente declaración relativa a un elemento de encabezado de tipo `MyBaseType`.

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

Nota:
En el caso de la declaración anterior, Xsd.exe todavía genera el siguiente campo (se omiten los atributos).

public MyBaseType Item;

Nota:
Xsd.exe no podrá generar clases si todos los elementos declarados globalmente en el esquema XML de entrada son abstractos.

Ejemplo: atributo Abstract

Documento de esquema XML de entrada.

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

Clases de C# generadas a partir del documento de esquema XML anterior.

[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;
}

El documento del esquema XML que se ha generado a partir de un ensamblado compilado con el anterior código fuente C#.

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

Atributo SubstitutionGroup

La herramienta Xsd.exe solo reconoce los grupos de sustitución si el elemento sustituido se ha declarado como abstracto. (Vea la sección anterior, Abstract Attribute). Entonces, en una traducción inversa, Xsd.exe genera un elemento <choice> que contiene un elemento <element> para cada uno de los sustitutos.

Atributo SubstitutionGroup: información general

El atributo substitutionGroup puede aparecer con un elemento declarado globalmente para permitirle que sustituya a otro elemento declarado globalmente en un documento XML de instancia. El valor del atributo es el nombre del elemento que se va a sustituir, al que se denomina encabezado. La sustitución propiamente dicha se realiza en un elemento <element> situado dentro de una definición de tipo complejo, donde se hace referencia al elemento de encabezado usando el atributo ref. Cualquier elemento que se declare con el atributo substitutionGroup deberá pertenecer al mismo tipo de datos que el elemento de encabezado, o a un tipo derivado.

Para permitir que elementos con nombres distintos y, opcionalmente, tipos distintos con el mismo tipo base aparezcan en una posición determinada de un documento de instancia, se utiliza un grupo de sustitución.

No se admiten los grupos de sustituciones anidados. Es decir, si un elemento actúa como elemento principal en un grupo de sustitución, no puede ser el elemento sustituido en otro grupo de sustitución. Por ejemplo.

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

No se admite porque Mammal actúa como elemento principal (para Dog) y como elemento sustituido (para Animal). Si se encuentra este tipo de esquema, Xsd.exe no generará un XmlElementAttribute para Mammal y el elemento Dog no se encontrará donde se espera que esté el elemento Animal. Sin embargo, puede agregarlo manualmente para que funcione, como se muestra en el ejemplo siguiente.

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

Atributo SubstitutionGroup: elemento principal concreto

Si el elemento de encabezado no es abstracto, Xsd.exe toma cada una de las referencias ref al encabezado y crea un campo del tipo correspondiente al tipo de datos XML del encabezado (o una matriz de ese tipo, en función del valor del atributo maxOccurs del elemento al que se hace referencia). Se perderá cualquier referencia al grupo de sustitución.

Aunque se puede asignar a ese campo un objeto de tipo derivado y la clase XmlSerializer serializa ese objeto, este comportamiento se produce fuera del ámbito de sustitución por tipos derivados. No se utiliza ningún nombre de elemento sustituto.

Atributo SubstitutionGroup: elemento de encabezado abstracto

Si el elemento de encabezado es abstracto, Xsd.exe genera un campo de un tipo correspondiente al tipo de datos del encabezado. Este campo recibe el nombre de Item. Xsd.exe aplica a este campo un atributo XmlElementAttribute para cada uno de los sustitutos. Cada atributo identifica el nombre y, si el elemento sustituto presenta un tipo de datos derivado, el tipo. Si los elementos sustitutos utilizan el mismo tipo de datos que el encabezado, también debe aplicarse un XmlChoiceIdentifierAttribute. Vea el elemento <choice>.

A continuación se muestra un campo de ejemplo generado a partir de una referencia a un elemento de encabezado abstracto.

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

Si se utilizan tipos de datos derivados, la serialización XML solo funcionará cuando se haya asignado al campo una instancia de uno de los tipos derivados. XmlSerializer produce un error si se ha asignado una instancia del tipo base que corresponda al elemento de encabezado.

En una traducción inversa, Xsd.exe genera a partir de esta construcción un elemento <choice> que contiene un elemento <element> por cada elemento sustituto, pero no para el elemento de encabezado. Los elementos se definen de forma independiente dentro de la definición de tipo complejo; no se utiliza ninguna referencia ref.

maxOccurs attribute. En una declaración <element> local con un atributo ref que especifica un elemento de encabezado abstracto, Xsd.exe omite el atributomaxOccurs.

Considere la siguiente declaración que hace referencia a un elemento de encabezado de tipo MyBaseType.

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

En el caso de la declaración anterior, Xsd.exe todavía genera el siguiente campo (se omiten los atributos).

public MyBaseType Item;

Ejemplo: atributo SubstitutionGroup

Documento de esquema XML de entrada.

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

Clases de C# generadas a partir del documento de esquema XML anterior.

[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;
}

El documento del esquema XML que se ha generado a partir de un ensamblado compilado con el anterior código fuente C#.

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

Atributos posibles	Compatibilidad de enlace
abstract	La utilidad Xsd.exe enlaza los grupos de sustitución utilizando declaraciones <element> abstractas, pero genera elementos <choice> en una traducción inversa. Vea la sección anterior, Atributo Abstract.
block	El atributo block se puede utilizar para impedir que las declaraciones de elementos se utilicen como encabezados de grupos de sustitución (los elementos que se sustituyen por miembros de grupos). La herramienta Xsd.exe omite el atributo block, así como el atributo blockDefault del elemento Compatibilidad con enlaces del elemento Schema.
default	El atributo default proporciona un valor predeterminado que se utilizará si el elemento está vacío en un documento de instancia. Si el elemento no aparece en modo alguno, no se rellena. Al generar código fuente a partir de un documento de esquema XML, la herramienta Xsd.exe toma cada campo correspondiente a un elemento con un valor predeterminado, aplica el atributo System.ComponentModel.DefaultValueAttribute y pasa el valor predeterminado como argumento. Además, Xsd.exe inicializa estáticamente el campo con el valor predeterminado, como en el ejemplo siguiente. `[System.ComponentModel.DefaultValueAttribute(-1)] public int age = -1;` Cuando se genera un elemento <element> a partir de un miembro de clase con un tipo de valor de .NET Framework, Xsd.exe utiliza el atributo DefaultValue como entrada al establecer el atributo minOccurs. Si Xsd.exe encuentra un atributo DefaultValue aplicado a este miembro, genera un valor de `0` para el atributo minOccurs del elemento. Esto indica que el elemento no tiene que aparecer en un documento XML de instancia válido. El atributo predeterminado se omite en las matrices (elementos con el valor de maxOccurs mayor que `1`). Vea el atributo Compatibilidad con enlaces del atributo Default.
final	El atributo final se puede utilizar para impedir que las declaraciones de elementos se utilicen como encabezados de grupos de sustitución (los elementos que se sustituyen por miembros de grupos). La herramienta Xsd.exe omite el atributo final, así como el atributo finalDefault del elemento <schema>.
fixed	El atributo fixed proporciona un valor fijo para el elemento en un documento de instancia. Cuando se genera código fuente a partir de un documento de esquema XML, Xsd.exe toma cada campo correspondiente a un elemento con un valor fijo y genera un inicializador estático para el campo, tal como se muestra en el siguiente ejemplo. `public int age = -1;` El atributo fijo se omite en las matrices (elementos con el valor de maxOccurs mayor que `1`).
form	La herramienta Xsd.exe equipara el atributo XML form del elemento <element> con la propiedad Form de XmlElementAttribute. La infraestructura de serialización XML de .NET Framework reconoce un valor predeterminado distinto, `qualified`. Si una declaración <element> de un esquema XML especifica `form="unqualified"`, Xsd.exe genera un atributo XmlElement para el campo correspondiente y pasa al atributo un parámetro, `Form=XmlSchemaForm.Unqualified`. Consulte el atributo form.
id	La utilidad Xsd.exe omite el atributo id, que está pensado para proporcionar un identificador único. En su lugar, Xsd.exe reconoce el atributo name.
maxOccurs	Cuando se generan clases a partir de un documento XSD, Xsd.exe interpreta el atributo maxOccurs del elemento <element> conforme a los siguientes valores posibles: `1`: Xsd.exe genera un campo del tipo correspondiente al tipo de datos del elemento. `0`: Xsd.exe no procesa el valor `0`, sino que lo considera como el valor `1` predeterminado. `unbounded`: Xsd.exe genera un campo que es una matriz del tipo correspondiente al tipo de datos del elemento. Cualquier entero mayor que 1: al igual que ocurre con los valores `unbounded`, Xsd.exe genera un campo que es una matriz del tipo correspondiente al tipo de datos del elemento. Puede imponer valores mayores que 1; para ello, tiene que validar un documento XML con la clase XmlValidatingReader con respecto a un documento de esquemas XML representado por el SOM. Cuando se genera un documento de esquemas XML a partir de un conjunto de clases de un ensamblado, Xsd.exe invierte las conversiones anteriores, y genera un valor para el atributo maxOccurs de `1` a partir de una única instancia y un valor para el atributo maxOccurs de `unbounded` a partir de una matriz. Cuando Xsd.exe enlaza un valor para el atributo maxOccurs de `unbounded` a una matriz, también enlaza un valor para el atributo maxOccurs de `1` al elemento principal de una matriz, si lo hubiere. Vea el atributo Compatibilidad con enlaces del atributo MaxOccurs para obtener más información sobre el tratamiento del elemento maxOccurs para los enlaces de matrices, incluida la designación de un elemento primario adicional.
minOccurs	En el caso del elemento <element>, Xsd.exe comprueba el valor del atributo minOccurs únicamente si el valor del atributo Compatibilidad con enlaces del atributo MaxOccurs no exige ningún campo de matriz. Después, el valor se interpreta (o se genera) con arreglo a distintos factores, empezando por si el campo correspondiente tiene un tipo de valor o de referencia. Consulte el atributo Compatibilidad con enlaces del atributo MinOccurs.
name	A la hora de generar código fuente a partir de un documento XSD, el valor del atributo name proporciona el nombre del campo de clase pública que representa al elemento. Si el elemento <element> contiene una definición anónima de <complexType>, el nombre pasa a ser el nombre de la clase que corresponde al tipo complejo. Para cumplir con las convenciones de codificación no se intenta ningún cambio de mayúsculas y minúsculas. Por ejemplo, si el atributo nombre de un <element> que contiene una definición anónima de tipo complejo tiene el valor `testInfo`, la clase subsiguiente adopta el nombre `testInfo`, en lugar de `TestInfo` (con mayúsculas). Si un nombre se encuentra en conflicto con una palabra clave reservada, el nombre resultante lleva el prefijo con el símbolo @. Cuando Xsd.exe genera una declaración <element> a partir de un campo de clase pública, utiliza el nombre de campo para el valor del atributo name. Se puede proporcionar un nombre alternativo (valor de atributo name) utilizando las siguientes propiedades de atributo: System.Xml.Serialization.XmlElementAttribute.ElementName System.Xml.Serialization.XmlArrayAttribute.ElementName: cambia el nombre del elemento XML primario de la matriz. System.Xml.Serialization.XmlArrayItemAttribute.ElementName: cambia los nombres de los elementos secundarios secuenciales que corresponden a las entradas de la matriz. System.Xml.Serialization.XmlRootAttribute.ElementName Consulte el atributo Compatibilidad con enlaces del atributo Name.
nillable	La herramienta Xsd.exe equipara el atributo nillable con la propiedad IsNullable de ciertos atributos relacionados con la serialización XML que se aplican a tipos de referencia. Para los tipos de valor, un valor nillable de true generará tipos que aceptan valores NULL. Consulte el atributo nillable. El atributo nillable solo aparece en el elemento <element>.
ref	Cuando se genera un tipo de .NET Framework a partir de un tipo complejo de esquema XML, Xsd.exe no diferencia un elemento declarado localmente de una referencia a un elemento declarado globalmente a menos que el elemento global se declare en un espacio de nombres distinto del espacio de nombres de destino del esquema. Consulte las secciones Referencia dentro del mismo espacio de nombres y Referencia a otro espacio de nombres.
substitutionGroup	La herramienta Xsd.exe solo reconoce los grupos de sustitución si el elemento sustituido se ha declarado como abstracto. Entonces, en una traducción inversa, Xsd.exe genera un elemento <choice> que contiene un elemento <element> para cada uno de los sustitutos. Vea la sección anterior, Atributo SubstitutionGroup.
type	La herramienta Xsd.exe asocia los tipos de datos a los que se hace referencia con el atributo type de las declaraciones <element> y <attribute> con los tipos .NET Framework. Xsd.exe no generará ningún tipo de .NET Framework para un tipo de datos de esquema XML a menos que pueda hacerse un seguimiento de la procedencia del tipo de datos hasta llegar a una declaración de elemento global que haga referencia a un tipo de datos (posiblemente otro) utilizando el atributo type.

Elementos primarios posibles: <all>, <choice>, <schema>, <sequence>

Posibles elementos secundarios: <annotation>, <complexType>, <key>, <keyref>, <simpleType>, <unique>

Vea también

Referencia

XmlSchemaElement

Compartir a través de

Compatibilidad con enlaces del elemento Element

Explicación

Referencia en el mismo espacio de nombres

Referencia a otro espacio de nombres

Creación de declaraciones de elementos globales

Atributo Abstract

Ejemplo: atributo Abstract

Atributo SubstitutionGroup

Atributo SubstitutionGroup: información general

Atributo SubstitutionGroup: elemento principal concreto

Atributo SubstitutionGroup: elemento de encabezado abstracto

Ejemplo: atributo SubstitutionGroup

Vea también

Referencia

Recursos adicionales