通过

element 元素绑定支持

.NET Framework 为 <element> 元素提供绑定支持。

说明

XML 架构规范规定，可以在复杂类型定义内局部声明某个元素，也可以通过全局声明的方式将它声明为根元素 <schema> 的子级。 如果该元素是全局声明的，则可以通过 ref 属性从一个或多个复杂类型定义引用它。

下面的代码示例演示一个局部声明的元素：

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

下面的代码示例演示先进行全局声明然后引用的同一元素：

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

当从 XML 架构复杂类型生成 .NET Framework 类型时，除非全局元素是在该架构的目标命名空间之外的命名空间中声明的，否则 Xsd.exe 不区分局部声明的元素和对全局声明的元素的引用。

同一命名空间内的引用

由于 Xsd.exe 不在同一命名空间内对二者进行区分，因此，当执行 XML 架构与类之间的往返转换时，会创建一些局部元素，这些元素将取代对全局元素的任何引用。

如果所引用的全局元素的数据类型已自动绑定到 .NET Framework 类型，则 Xsd.exe 将不会生成与该数据类型对应的新类型。 因此，在往返行程中生成的 XML 架构中，不但不再引用全局元素声明，而且将不再显示该声明。

Note注意:

所有内置的 XML 架构数据类型都自动绑定到 .NET Framework 类型。 此外，架构定义的简单类型绑定到 .NET Framework 类型，而不是绑定到自定义类型，但有一个例外。 这个例外涉及到字符串绑定类型的枚举；在关于 <enumeration> 元素的文档中，有对此例外的更详细说明。
Note注意:

有关对架构定义的简单类型的支持的更多信息，请参见 <restriction> 元素或表示限制方面的任何元素。

对另一个命名空间的引用

如果所引用的全局声明属于另一个命名空间，则 Xsd.exe 使用应用于所生成的字段的 XmlElementAttribute 属性 (Attribute) 的 Namespace 属性 (Property) 来指定该命名空间。 对于该特定元素，通过 Namespace 属性 (Property) 指定的命名空间重写使用 XmlTypeAttribute 属性 (Attribute) 和 XmlRootAttribute（可选）在类级别指定的命名空间。 下面是一个示例：

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

其他命名空间是使用 <import> 元素导入到 XML 架构定义中的。

创建全局元素声明

当基于程序集中的一组类生成 XML 架构文档时，Xsd.exe 会为它基于该程序集中定义的类型生成的每个 <complexType> 或 <simpleType> 定义生成一个全局 <element> 声明。

第一个示例显示了当在包含对某个全局元素的引用的同一个目标命名空间中定义该元素时，Xsd.exe 如何处理该全局元素。

输入 XML 架构文档：

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

基于前面的 XML 架构文档生成的 C# 类：

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

基于通过前面的 C# 源代码编译得到的程序集生成的 XML 架构文档：

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

在前面生成的 XML 架构中，Text 元素（最初是全局声明的）已成为局部元素。

第二个示例演示当在一个单独的命名空间中定义某个全局元素时，Xsd.exe 如何处理对该元素的引用。 此示例使用 <import> 元素导入另一个位于单独的 XSD 文件中的命名空间。 （<import> 元素的 schemaLocation 属性不用于指定导入的 .xsd 文件的位置。 对于 Xsd.exe 而言，该文件作为一个附加的命令行参数来指定。）

用作输入的顶级 XML 架构文档：

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

用作输入的已导入 XML 架构文档：

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

基于前面的两个 XML 架构文档生成的 C# 类：

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

基于通过前面的 C# 源代码编译得到的程序集生成的顶级 XML 架构文档：

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

基于通过前面的 C# 源代码编译得到的程序集生成的已导入 XML 架构文档：

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

abstract 属性

全局元素声明可以具有 abstract 属性；而局部元素则不能。

如果将某个元素声明为抽象元素 (abstract="true")，则会强制通过替换组替换它；如果该元素不是抽象的，则替换是可选的。

被替换的全局元素称作头元素。 只要局部元素声明通过 ref 属性引用头元素，您就可以用任何全局替换元素来替换该局部元素。 有关更多信息，请参见 substitutionGroup 属性。

如果替换元素属于派生的数据类型，而且头元素本身被声明为抽象，而不是声明为 <complexType> 定义（该定义的类型被声明为抽象），则您可以在 XML 实例文档中的其他位置使用基类型，但您不能在发生替换的位置使用它。

当从 XML 架构文档生成源代码时，Xsd.exe 生成一个与头元素的数据类型对应的类型。 该类型包括一个名为 Item 的字段。 对于每个替换元素，Xsd.exe 都向该字段应用一个 XmlElementAttribute。 每个属性都标识名称，而且，如果替换元素具有派生的数据类型，还标识该类型。 如果替换元素使用与头相同的数据类型，则还必须应用 XmlChoiceIdentifierAttribute。 有关更多信息，请参见 <choice> 元素。

下面的代码示例演示一个示例字段 Item，该字段是从对抽象头元素的引用生成的：

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

如果要使用属于派生数据类型的替换元素，那么，只有在向该字段分配了某个派生类型的实例时，XML 序列化功能才有效。 如果已经分配了与头元素对应的基类型的实例，XmlSerializer 类将失败。

在进行反向转换时，Xsd.exe 会生成一个 <choice> 元素，其中包含与每个替换元素一一对应的 <element> 元素，但不包含表示头元素的 <element>。 这些元素是在复杂类型定义内部单独定义的；不采用任何 ref 引用。

Note注意:

在包含指定抽象头元素的 ref 属性的局部 <element> 声明中，Xsd.exe 忽略 maxOccurs 属性。
Note注意:

考虑下面对一个 MyBaseType 类型的头元素的声明：

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

对于前面的声明，Xsd.exe 仍生成以下字段（省略了属性）：

 
public MyBaseType Item;
Note注意:

如果输入 XML 架构中所有全局声明的元素均为抽象元素，则 Xsd.exe 将无法生成类。

示例：abstract 属性

输入 XML 架构文档：

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

基于前面的 XML 架构文档生成的 C# 类：

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

基于通过前面的 C# 源代码编译得到的程序集生成的 XML 架构文档：

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

substitutionGroup 属性

仅当被替换元素声明为抽象元素时，Xsd.exe 工具才能识别替换组。 （请参见前面的 Abstract Attribute部分。） 然后，在进行反向转换时，Xsd.exe 会生成一个 <choice> 元素，对于每个替换元素，其中都包含有一个 <element> 元素。

substitutionGroup 属性：背景

substitutionGroup 属性可以出现于全局声明的元素中，使该元素可以取代 XML 实例文档中另一个全局声明的元素。 属性值是要替换的元素（称为头元素）的名称。 实际的替换可以发生在复杂类型定义内的 <element> 元素中，在该定义中，头元素是通过 ref 属性引用的。 用 substitutionGroup 属性声明的任何元素都必须与头元素属于相同的数据类型，或者属于头元素数据类型的派生类型。

使用替换组，可以允许在实例文档中的指定位置出现不同名称和（基类型相同的）不同类型的元素（可选）。

不支持嵌套替换组。 即，如果一个元素在一个替换组中作为头元素，它就不能在另一个替换组中成为被替换元素。 例如：

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

不支持该操作，因为 Mammal 既作为头元素 (Dog) 也作为被替换元素 (Animal)。 如果遇到此类情形，Xsd.exe 将不会为 Mammal 生成 XmlElementAttribute，Dog 也不会在 Animal 元素应该出现的地方。 但是，您可以进行手动添加以使其起作用，如下面的示例所示：

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

substitutionGroup 属性：具体的头元素

如果头元素不是抽象元素，则 Xsd.exe 会提取对头元素的每个 ref 引用，创建一个类型与头元素的 XML 数据类型对应的字段或数组，具体取决于引用元素的 maxOccurs 属性的值。 对替换组的任何引用都将丢失。

尽管可以向该字段分配派生类型的对象，而且 XmlSerializer 类将序列化该对象，但是，该行为将发生在使用派生类型的替换之外。 不使用替换元素名称。

substitutionGroup 属性：抽象头元素

如果头元素是抽象元素，则 Xsd.exe 会生成一个类型与头元素的数据类型对应的字段。 该字段接收名称 Item。 对于每个替换元素，Xsd.exe 都向该字段应用一个 XmlElementAttribute。 每个属性都标识名称，而且，如果替换元素具有派生的数据类型，还标识该类型。 如果替换元素使用与头相同的数据类型，则还必须应用 XmlChoiceIdentifierAttribute。 请参见 <choice> 元素。

下面的示例字段是基于对抽象头元素的引用生成的：

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

如果使用派生类型，那么，只有在向该字段分配了某个派生类型的实例时，XML 序列化功能才有效。 如果已经分配了与头元素对应的基类型的实例，XmlSerializer 将失败。

在进行反向转换时，Xsd.exe 会从此构造生成一个 <choice> 元素，其中包含与每个替换元素（而非头元素）一一对应的 <element> 元素。 这些元素是在复杂类型定义内部单独定义的；不采用任何 ref 引用。

maxOccurs 属性。 对于包含指定抽象头元素的 ref 属性的局部 <element> 声明，Xsd.exe 忽略 maxOccurs 属性。

请考虑下面的声明，它引用一个 MyBaseType 类型的头元素：

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

对于前面的声明，Xsd.exe 仍生成以下字段（省略了属性）：

public MyBaseType Item;

示例：substitutionGroup 属性

输入 XML 架构文档：

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

基于前面的 XML 架构文档生成的 C# 类：

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

基于通过前面的 C# 源代码编译得到的程序集生成的 XML 架构文档：

<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>
可能的属性 绑定支持

abstract

Xsd.exe 实用工具使用抽象 <element> 声明绑定替换组，但在反向转换中生成 <choice> 元素。

请参见前面的“Abstract 属性”一节。

block

block 属性可用来防止将元素声明用作替换组的头（可以被组成员替换的元素）。

Xsd.exe 工具忽略 block 属性，以及 schema 元素绑定支持 元素的 blockDefault 属性。

default

default 属性提供默认值，如果该元素在实例文档中为空，将使用该默认值。 如果该元素根本不出现，则不会填充它。

当从 XML 架构文档生成源代码时，Xsd.exe 工具会提取与具有默认值的元素对应的每个字段，应用 System.ComponentModel.DefaultValueAttribute，并将默认值作为参数传递。 此外，Xsd.exe 还以静态方式将该字段初始化为默认值，如下面的示例所示：

[System.ComponentModel.DefaultValueAttribute(-1)]
public int age = -1;

在从具有 .NET Framework 值类型的类成员生成 <element> 元素时，Xsd.exe 将 DefaultValue 属性用作设置 minOccurs 属性时的输入。 如果 Xsd.exe 遇到应用于此类成员的 DefaultValue 属性，会为该元素的 minOccurs 属性生成值 0。 这表示该元素不必出现在有效的 XML 实例文档中。

在数组（maxOccurs 大于 1 的元素）上忽略默认属性。

请参见 default 属性绑定支持 属性。

final

final 属性可用来防止将元素声明用作替换组的头（可以被组成员替换的元素）。

Xsd.exe 会忽略 final 属性，以及 <schema> 元素的 finalDefault 属性。

fixed

fixed 属性为实例文档中的元素提供固定值。 从 XML 架构文档生成源代码时，Xsd.exe 会为每个具有固定值的元素都提取一个字段，然后生成该字段的静态初始值设定项，如下面的示例所示：

public int age = -1;

在数组（maxOccurs 大于 1 的元素）上忽略 fixed 属性。

form

Xsd.exe 工具将 <element> 元素的 form XML 属性 (Attribute) 等同于 XmlElementAttribute 的 Form 属性 (Property)。 .NET Framework 的 XML 序列化基础结构可识别另一默认值 qualified。

如果 XML 架构中的 <element> 声明指定 form="unqualified"，则 Xsd.exe 会为对应的字段生成 XmlElement 属性，并为该属性传递参数 Form=XmlSchemaForm.Unqualified。

请参见 form 属性。

id

Xsd.exe 实用工具会忽略旨在提供唯一标识符的 id 属性。 而改为识别 name 属性。

maxOccurs

当从 XSD 文档生成类时，Xsd.exe 会按照下列可能值解释 <element> 元素中的 maxOccurs 属性：

  • 1：Xsd.exe 生成类型与元素的数据类型对应的字段。

  • 0：Xsd.exe 处理值 0 失败，而改为将该值作为默认值 1 处理。

  • unbounded：Xsd.exe 生成一个字段，该字段是类型与元素的数据类型对应的数组。

  • 大于 1 的任何整数：与 unbounded 值相同，Xsd.exe 生成一个字段，该字段是类型与元素的数据类型对应的数组。 可以使用 XmlValidatingReader 类对照 SOM 表示的 XML 架构文档验证 XML 文档，从而强制使用大于 1 的值。

当基于程序集中的一组类生成 XML 架构文档时，Xsd.exe 执行上述转换的反向转换，从单个实例生成 maxOccurs 值 1，从数组生成 maxOccurs 值 unbounded。

尽管 Xsd.exe 将 maxOccurs 值 unbounded 绑定到数组，但是它将 maxOccurs 值 1 绑定到数组的指定父元素（如果有的话）。 有关针对数组绑定处理 maxOccurs 元素（包括指定额外的父元素）的更多信息，请参见 maxOccurs 属性绑定支持 属性。

minOccurs

对于 <element> 元素，只有当 maxOccurs 属性绑定支持 属性的值不指示数组字段时，Xsd.exe 才检查 minOccurs 属性的值。 然后，从对应的字段属于引用类型还是值类型开始，按照各种因素解释（或生成）值。

请参见 minOccurs 属性绑定支持 属性。

name

如果要从 XSD 文档生成源代码，则 name 属性的值提供表示该元素的公共类字段的名称。 如果 <element> 元素包含匿名的 <complexType> 定义，则该名称会变成与复杂类型相对应的类的名称。

不要为了遵循编码约定而试图更改大小写。 例如，如果包含匿名复杂类型定义的 <element> 的 name 属性具有值 testInfo，则结果类的名称将为 testInfo，而不是首字母大写的 TestInfo。 如果名称与保留的关键字冲突，则会生成一个带有符号 @ 前缀的名称。

当 Xsd.exe 从某个公共类字段生成 <element> 声明时，会将该字段的名称用于 name 属性的值。 可通过下列属性 (Attribute) 属性 (Property) 来提供替代名称 - name 属性 (Attribute) 值：

请参见 name 属性绑定支持 属性。

nillable

Xsd.exe 工具将 nillable 属性 (Attribute) 等同于某些应用于引用类型的 XML 序列化相关属性 (Attribute) 的 IsNullable 属性 (Property)。 对于值类型，值为 true 的 nillable 将导致生成可以为 null 的类型。

请参见 nillable 属性。 nillable 属性仅出现在 <element> 元素中。

ref

当从 XML 架构复杂类型生成 .NET Framework 类型时，除非全局元素是在该架构的目标命名空间之外的命名空间中声明的，否则 Xsd.exe 不区分局部声明的元素和对全局声明的元素的引用。

请参见同一命名空间内的引用和对另一个命名空间的引用部分。

substitutionGroup

仅当被替换元素声明为抽象元素时，Xsd.exe 工具才能识别替换组。 然后，在进行反向转换时，Xsd.exe 会生成一个 <choice> 元素，对于每个替换元素，其中都包含有一个 <element> 元素。

请参见前面的“substitutionGroup 属性”部分。

type

Xsd.exe tool 工具将使用 <element> 和 <attribute> 声明的 type 属性引用的数据类型与 .NET Framework 类型关联。

除非某个 XML 架构数据类型可以追溯到通过 type 属性引用某个数据类型（可能是另一个数据类型）的全局元素声明，否则 Xsd.exe 不会为该 XML 架构数据类型生成 .NET Framework 类型。

可能的父元素：<all>、<choice>、<schema>、<sequence>

可能的子元素：<annotation>、<complexType>、<key>、<keyref>、<simpleType>、<unique>

请参见

参考

XmlSchemaElement

Footer image

版权所有 (C) 2007 Microsoft Corporation。保留所有权利。