XSD: Agregar atributos a elementos "simples" fuertemente tipados

Question

¿Hay alguna manera sensata de tener elementos con tipos simples fuertemente tipados y también atributos?

Está bien, tienen un esquema XSD que tiene una serie de elementos millones (er, cien) que podría tener este aspecto:

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

Eso es Dandy. Sin embargo, realmente quiero que todos estos elementos también tengan algunos atributos comunes en ellos como, digamos, "formato" y "isVisible". es decir, tiene un esquema como:

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

que podría hacerlo de forma manual, y horriblemente, sumando todos estos atributos al XSD cuando generarlo, algo como esto:

<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 

... pero en un mundo ideal prefiero defino como un complexType:

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

... lo que significa que sólo podía hacer:

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

El problema con mi código "mundo ideal" es que:

a) no tengo válida <xsd:extension base-"???">, ya que realmente no me importa lo que yo estoy extendiendo; Quiero extender todos los tipos. Parece que el "xsd: anyType" es apropiado, pero luego el elemento se convierte en un contenedor débilmente tipado, ¿no es así?

b) Ya no puedo especificar el tipo simple en el <xsd:element>, ya que ahora el tipo es el complejo "customType" que definí. De ahí el atributo "baseType" imaginario que puse allí ...

¿Puedo agregar atributos a los tipos simples de una manera no grotesca? ¿O necesito definir una docena de ComplexTypes que sean todos idénticos, excepto por el tipo simple que extienden?

Los elementos fuertemente tipados no solo describen los datos de forma más sensata, sino que cuando los utilizo para mapeo XML en Excel (y este es el propósito de todo esto), el tipado fuerte significa que Excel establece el formato de celda correctamente basado en el tipo.

¡Probablemente estoy viendo todo de la manera incorrecta! Cualquier consejo apreciado.

Answer 1

[cita] podría hacerlo de forma manual, y horriblemente, por sumando todos estos atributos al XSD cuando generarlo, algo así como esto: [/ quote]

Me temo que esta es su única forma "adecuada" compatible con XSD-schema para hacerlo.

XSD puede ser enrevesado al autor a veces - pero ayuda a mantener las cosas seguras :-)

Marc

Answer 2

El propósito de un XSD es describir los datos. El propósito del atributo de tipo de un XSD es describir o definir un elemento.Lo que quiere hacer es cambiar la definición del elemento. Si está cambiando la descripción, cambie el tipo. Lo que estás tratando de hacer es como poner ruedas en un pensamiento. "Pero yo quiero ruedas en mi pensamiento!" "Lo siento, no puedo hacer".

Answer 3

No está del todo claro qué aspecto de la solución manual considera horrible; si es la idea de tener que definir n diferentes tipos simplemente porque necesitarán ampliar n tipos de base diferentes, entonces estás atascado.

Si se trata de la idea de tener que tener n declaraciones diferentes para los format y isVisible atributos, entonces puede que le resulte menos horrible para utilizar un grupo de atributos de llamada para mantener esas definiciones:

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

El declaraciones de los distintos tipos complejos que necesitan seguir siendo repetitivo pero ahora son un poco menos detallado:

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

y las declaraciones de sus elementos son ahora es ligeramente más sencillo que en su caso 'ideal':

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