XSD 架构中的元素强制属性声明:

发布于 2024-12-09 03:13:04 字数 645 浏览 0 评论 0原文

我想声明一个要包含在复杂类型声明中的元素,并且该元素具有强制属性:“option=MyOption”,但是“option”属性的值可以是任何值,具体取决于上下文。

也就是说:在任何使用包含该元素的复杂类型的文档中,具有未知值的属性“option”应该是强制的。

示例:

    <xs:element name="SpecialOption" type="xs:string"/>

    <xs:complexType name="SpecialOptions">
        <xs:sequence>
            <xs:element ref="SpecialOption" minOccurs="1" maxOccurs="100"/>
            <xs:element ref="XXX"/>     
        </xs:sequence>
    </xs:complexType>   

在这种情况下,复杂类型“SpecialOptions”中的“SpecialOption”元素应具有此强制属性。

我不知道如何在 XSD 中声明元素的强制属性,或者如何指定该属性必须具有未知的值。

I want to declare an element to be included in a complex type declaration, and the element has a mandatory attribute: "option=MyOption", but the value of the "option" attribute could be anything, depending on the context.

That is: the attribute "option" with some unknown value should be mandatory in any document using the complex type containing this element.

Example:

    <xs:element name="SpecialOption" type="xs:string"/>

    <xs:complexType name="SpecialOptions">
        <xs:sequence>
            <xs:element ref="SpecialOption" minOccurs="1" maxOccurs="100"/>
            <xs:element ref="XXX"/>     
        </xs:sequence>
    </xs:complexType>   

In this case the "SpecialOption" element in the complex type "SpecialOptions" should have this mandatory attribute.

I don't know how to declare a mandatory attribute for an element in XSD, or how to specify that the attribute must have a value that is not yet known.

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(4

拥抱没勇气 2024-12-16 03:13:04

您需要修改“SpecialOption”元素的定义以包含所需的属性。将此代码更新

<xs:element name="SpecialOption" type="xs:string"/>

<xs:element name="SpecialOption">
  <xs:complexType>
    <xs:simpleContent>
      <xs:extension base="xs:string">
        <xs:attribute name="Option" type="xs:string" use="required"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
</xs:element>

:通过此更改,您的复杂类型将在“SpecialOptions”复杂类型中的“SpecialOption”元素的所有实例上包含所需的“Option”属性。将“Option”属性声明为 xs:string 类型将允许在此字段中传递任何值。

You need to modify the definition of the "SpecialOption" element to include the required attribute. Update this code:

<xs:element name="SpecialOption" type="xs:string"/>

to this:

<xs:element name="SpecialOption">
  <xs:complexType>
    <xs:simpleContent>
      <xs:extension base="xs:string">
        <xs:attribute name="Option" type="xs:string" use="required"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
</xs:element>

With this change your complex type will contain the required "Option" attribute on all instances of the "SpecialOption" element in the "SpecialOptions" complex type. Declaring the "Option" attribute to be of type xs:string will allow any value to be passed in this field.

无远思近则忧 2024-12-16 03:13:04

1) 这是一个简单的必需字符串属性

<xs:element name="SpecialOption">
    <xs:complexType>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute name="Option" type="xs:string" use="required"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
</xs:element> 

2) 精确地要求允许值列表中的一个:

<xs:element name="SpecialOption">
    <xs:complexType>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute name="Option" use="required">
                    <xs:simpleType>  
                        <xs:restriction base="xs:string">  
                            <xs:enumeration value="DE"/>  
                            <xs:enumeration value="EN"/>  
                        </xs:restriction>  
                    </xs:simpleType>  
                </xs:attribute>  
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
</xs:element> 

3) 可以使用范围作为限制,如下例所示。

<xs:element name="SpecialOption">
    <xs:complexType>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute name="Option" use="required">
                    <xs:simpleType>  
                        <xs:restriction base="xs:integer">  
                            <xs:minInclusive value="95"/>  
                            <xs:maxInclusive value="137"/>  
                        </xs:restriction>  
                    </xs:simpleType>  
                </xs:attribute>  
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
</xs:element> 

4) 下面,属性被声明为包含十进制值的列表。这允许属性包含指定值的子集,例如Option="6 77 95"。

<xs:simpleType name="Items">  
    <xs:restriction base="xs:decimal">  
        <xs:enumeration value="137"/>  
        <xs:enumeration value="95"/>  
        <xs:enumeration value="6"/>  
        <xs:enumeration value="77"/>  
    </xs:restriction>  
</xs:simpleType>  
<xs:element name="SpecialOption">
    <xs:complexType>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute name="Option" use="required">
                    <xs:simpleType>  
                        <xs:list itemType="Items"/>  
                    </xs:simpleType>  
                </xs:attribute>  
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
</xs:element> 

5) 此处该属性被声明为可选,但提供了默认值(“test”),有时这就足够了:

<xs:element name="SpecialOption">
    <xs:complexType>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute name="Option" type="xs:string" use="optional" default="test"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
</xs:element> 

1) This is a simple required string attribute

<xs:element name="SpecialOption">
    <xs:complexType>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute name="Option" type="xs:string" use="required"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
</xs:element> 

2) To require exactly one of a list of allowed values:

<xs:element name="SpecialOption">
    <xs:complexType>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute name="Option" use="required">
                    <xs:simpleType>  
                        <xs:restriction base="xs:string">  
                            <xs:enumeration value="DE"/>  
                            <xs:enumeration value="EN"/>  
                        </xs:restriction>  
                    </xs:simpleType>  
                </xs:attribute>  
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
</xs:element> 

3) One can use a range as a restriction, like in the example below.

<xs:element name="SpecialOption">
    <xs:complexType>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute name="Option" use="required">
                    <xs:simpleType>  
                        <xs:restriction base="xs:integer">  
                            <xs:minInclusive value="95"/>  
                            <xs:maxInclusive value="137"/>  
                        </xs:restriction>  
                    </xs:simpleType>  
                </xs:attribute>  
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
</xs:element> 

4) Below, the attribute is declared as a list containing decimal values. This allows an attribute to contain a subset of the specified values, e.g. Option="6 77 95".

<xs:simpleType name="Items">  
    <xs:restriction base="xs:decimal">  
        <xs:enumeration value="137"/>  
        <xs:enumeration value="95"/>  
        <xs:enumeration value="6"/>  
        <xs:enumeration value="77"/>  
    </xs:restriction>  
</xs:simpleType>  
<xs:element name="SpecialOption">
    <xs:complexType>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute name="Option" use="required">
                    <xs:simpleType>  
                        <xs:list itemType="Items"/>  
                    </xs:simpleType>  
                </xs:attribute>  
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
</xs:element> 

5) Here the attribute is declared optional, but provided with a default value ("test"), which is sometimes sufficient:

<xs:element name="SpecialOption">
    <xs:complexType>
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:attribute name="Option" type="xs:string" use="optional" default="test"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
</xs:element> 
饮惑 2024-12-16 03:13:04

要将属性标记为强制属性,请使用

至于类型,您可以选择内置的 XSD 类型(xs:string 等),也可以定义自己的 并使用它。

更新

我不确定您所说的属性必须具有未知的值是什么意思。这是否意味着该值是一个字符串,但可以是任何字符串?还是小数?

因为我们正在谈论它是一个属性值,所以您只能使用内置 XSD 类型,或者基于其中一种内置类型定义您自己的 xs:simpleType 类型。您可以在此处对允许的值应用更严格的规则,例如通过扩展 xs:string 并向允许的值添加正则表达式约束。

<xsd:simpleType name="UKDate">
    <xsd:restriction base="xsd:string">
        <xsd:pattern value="(0?[1-9]|[12][0-9]|3[01])[- /.](0?[1-9]|1[012])[- /.](19|20)\d\d"/>
    </xsd:restriction>
</xsd:simpleType>

但是,如果完全无法知道将使用什么值,那么您就会遇到众所周知的时间悖论,即您无法在设计时将某些内容限制为仅在运行时知道的值。在这种情况下,肯定只需要指定该属性至少必须存在吧?

希望这能更清楚地回答您的问题。

To mark an attribute as mandatory you use <xs:attribute use="required" />.

As for type, you have a choice of the built-in XSD types (xs:string etc), or you can define your own <xs:simpleType /> and use that.

UPDATE

I am not certain what you mean by the attribute must have a value that is not yet known. Does this mean that the value is a string, but can be any string? Or a decimal?

Because it's an attribute value we are talking about you are restricted to using the built-in XSD types, or defining your own xs:simpleType type based on one of the built-in types. This is where you can apply more stringent rules to the allowed value, for example by extending xs:string and adding a regular expression constraint to allowed values.

<xsd:simpleType name="UKDate">
    <xsd:restriction base="xsd:string">
        <xsd:pattern value="(0?[1-9]|[12][0-9]|3[01])[- /.](0?[1-9]|1[012])[- /.](19|20)\d\d"/>
    </xsd:restriction>
</xsd:simpleType>

However, if there is absolutely no way of knowing what value will be used then you have the well known temporal paradox whereby you cannot restrict something at design-time to a value you only know at run-time. In this instance, surely it is only necessary to specify that the attribute must at least be present?

<xs:attribute use="required" />

Hope this answers your question a little more clearly.

你的心境我的脸 2024-12-16 03:13:04

您只需按照以下代码执行此操作即可

<xs:element name="SpecialOption">
      <xs:simpleType>
        <xs:restriction base="xs:string">
          <xs:whiteSpace value="replace"/>
          <xs:minLength value="1"></xs:minLength>
        </xs:restriction>
      </xs:simpleType>
    </xs:element>

强制在 xml 标记上插入一个值,并且空白限制将处理以从 xml 标记中删除空白。

Simply you can do it as the following

<xs:element name="SpecialOption">
      <xs:simpleType>
        <xs:restriction base="xs:string">
          <xs:whiteSpace value="replace"/>
          <xs:minLength value="1"></xs:minLength>
        </xs:restriction>
      </xs:simpleType>
    </xs:element>

by this code you enforce to insert a value on the xml tag and also the white space restriction will handle to remove the white space from the xml tag.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文