XSD: Ajout d'attributs à des éléments "simples" fortement typés

Question

Existe-t-il un moyen sensé d'avoir des éléments avec des types simples et des attributs fortement typés?

D'accord, j'ai un schéma XSD qui a un million d'éléments (er, cent) qui pourrait ressembler à ceci:

<xsd:element name="DocumentDescription" type="xsd:string" /> 
<xsd:element name="DocumentDateTime" type="xsd:dateTime" /> 
<xsd:element name="DocumentSize" type="xsd:int" /> 

C'est dandy. Cependant, je veux vraiment que tous ces éléments aient aussi des attributs communs comme, disons, "format" et "isVisible". dire avoir un schéma comme:

<DocumentDescription isVisible="true">doc description</DocumentDescription> 
<DocumentDateTime format="dd/mm/yyyy" isVisible="true">1/1/2008</DocumentDescription> 
<DocumentSize format="0.00 KB" isVisible="false">5403</DocumentSize> 

je pouvais le faire manuellement, et horriblement, en ajoutant tous ces attributs à la XSD quand je produis, quelque chose comme ceci:

<xsd:element name="DocumentDescription" /> 
    <xsd:complexType> 
    <xsd:simpleContent> 
     <xsd:extension base="xsd:string"> 
     <xsd:attribute name="format" type="xsd:string" /> 
     <xsd:attribute name="isVisible" type="xsd:boolean" /> 
     </xsd:extension> 
    </xsd:simpleContent> 
    </xsd:complexType> 
<xsd:element name="DocumentDateTime" /> 
    ... etc 

... mais dans un monde idéal, je préfère définir comme complexType:

<xsd:complexType name="customType"> 
    <xsd:complexContent> 
    <xsd:extension base="???"> 
     <xsd:attribute name="format" type="xsd:string" /> 
     <xsd:attribute name="isVisible" type="xsd:boolean" /> 

... ce qui signifie que je pouvais faire:

<xsd:element name="DocumentDescription" type="customType" baseType="xsd:string" /> 
<xsd:element name="DocumentDateTime" type="customType" baseType="xsd:dateTime" /> 
<xsd:element name="DocumentSize" type="customType" baseType="xsd:int" /> 

Le problème avec mon code « monde idéal » est que:

a) Je n'ai pas <xsd:extension base-"???" valide>, car vraiment je ne me soucie pas de ce que je suis extension; Je veux étendre tous les types. On dirait que le "xsd: anyType" est approprié, mais alors l'élément devient un conteneur faiblement typé, n'est-ce pas?

b) Je ne peux plus spécifier le type simple sur le <xsd:element>, puisque maintenant le type est le "customType" complexe que j'ai défini. D'où l'attribut imaginaire "baseType" que j'ai mis là ...

Puis-je ajouter des attributs à des types simples d'une manière non-maladroite? Ou ai-je besoin de définir une douzaine de types complexes qui sont tous identiques à l'exception du type simple qu'ils étendent? Les éléments fortement typés décrivent non seulement les données de manière plus judicieuse, mais quand je les utilise pour le mappage XML dans Excel (et c'est le but de ces choses), le typage fort signifie qu'Excel définit correctement le formatage des cellules basé sur le type.

Je regarde probablement tout de travers! Tout conseil apprécié.

Answer 1

[quote] pourrait le faire manuellement, et horriblement en ajoutant tous ces attributs à la XSD quand je produis, quelque chose comme ceci: [/ quote]

Je crains que ce soit votre seul moyen "approprié", compatible avec le schéma XSD.

XSD peut être contournés à l'auteur parfois - mais il aide les choses en toute sécurité :-) garder

Marc

Answer 2

Le but d'un XSD est de décrire vos données. Le but d'un attribut de type XSD est de décrire ou de définir un élément.Ce que vous voulez faire est de changer la définition de l'élément. Si vous changez la description, changez le type. Ce que vous essayez de faire, c'est comme mettre des roues sur une pensée. "Mais je veut roues sur ma pensée!" "Désolé, impossible de faire."

Answer 3

Il n'est pas tout à fait clair quel aspect de la solution manuelle vous considérez comme horrible; si c'est l'idée d'avoir à définir n différents types tout simplement parce qu'ils devront étendre n différents types de base, alors vous êtes coincé.

Si c'est l'idée d'avoir à avoir n déclarations différentes pour les format et isVisible attributs, vous trouverez peut-être moins horrible d'utiliser un groupe d'attributs nommé pour contenir ces définitions:

<xs:attributeGroup name="globals"> 
    <xs:attribute name="format" type="xs:string"/> 
    <xs:attribute name="isVisible" type="xs:boolean"/> 
</xs:attributeGroup> 

Le déclarations des différents types complexes que vous devez rester répétitif, mais sont maintenant un peu moins bavard:

<xs:complexType name="string"> 
    <xs:simpleContent> 
    <xs:extension base="xs:string"> 
     <xs:attributeGroup ref="my:globals"/> 
    </xs:extension> 
    </xs:simpleContent> 
</xs:complexType> 
<xs:complexType name="dateTime"> 
    <xs:simpleContent> 
    <xs:extension base="xs:dateTime"> 
     <xs:attributeGroup ref="my:globals"/> 
    </xs:extension> 
    </xs:simpleContent> 
</xs:complexType> 
<xs:complexType name="int"> 
    <xs:simpleContent> 
    <xs:extension base="xs:int"> 
     <xs:attributeGroup ref="my:globals"/> 
    </xs:extension> 
    </xs:simpleContent> 
</xs:complexType> 

Et les déclarations de vos éléments sont maintenant s légèrement plus simple que dans votre 'idéal' cas:

<xs:element name="DocumentDescription" type="my:string" /> 
<xs:element name="DocumentDateTime" type="my:dateTime" /> 
<xs:element name="DocumentSize" type="my:int" />