Edición de esquemas XML
La edición de un esquema XML es una de las características más importantes del Modelo de objetos de esquema (SOM). Se pueden utilizar todas las propiedades previas a la compilación de esquemas del SOM para cambiar los valores existentes de un esquema XML. Luego, el esquema XML se puede volver a compilar para reflejar los cambios.
El primer paso para editar un esquema cargado en el SOM consiste en atravesar el esquema. Debería familiarizarse con el proceso de atravesar un esquema utilizando la API del SOM antes de intentar editar un esquema. También debería familiarizarse con las propiedades posteriores y anteriores a la compilación de esquemas del conjunto de información posterior a la compilación de esquemas (PSCI).
Edición de un esquema XML
En esta sección se incluyen dos ejemplos de código que editan el esquema del cliente que se creó en el tema Compilar esquemas XML. En el primer ejemplo de código se agrega un nuevo elemento PhoneNumber al elemento Customer y, en el segundo, se agrega un nuevo atributo Title al elemento FirstName. En el primer ejemplo también se utiliza la colección XmlSchema.Elements posterior a la compilación de esquemas como medio para atravesar el esquema del cliente, mientras que en el segundo ejemplo se utiliza la colección XmlSchema.Items previa a la compilación de esquemas.
Ejemplo del elemento PhoneNumber
En el primer ejemplo de código se agrega un nuevo elemento PhoneNumber al elemento Customer del esquema del cliente. El ejemplo de código edita el esquema del cliente en los siguientes pasos.
Agrega el esquema del cliente a un objeto XmlSchemaSet nuevo y luego lo compila. Cualquier error o advertencia de validación de esquemas que se encuentre durante la lectura o compilación del esquema se controla por medio del delegado ValidationEventHandler.
Recupera el objeto XmlSchema compilado desde XmlSchemaSet iterando por la propiedad Schemas. Puesto que el esquema se compila, las propiedades del conjunto de información posterior a la compilación del esquema son accesibles.
Crea el elemento PhoneNumber utilizando la clase XmlSchemaElement, la restricción de tipos simples xs:string utilizando las clases XmlSchemaSimpleType y XmlSchemaSimpleTypeRestriction, agrega una faceta de modelo a la propiedad Facets de la restricción, y agrega la restricción a la propiedad Content del tipo simple y el tipo simple al SchemaType del elemento PhoneNumber.
Itera por cada XmlSchemaElement de la colección Values de la colección XmlSchema.Elements posterior a la compilación de esquemas.
Si el QualifiedName del elemento es "Customer", se obtiene el tipo complejo del elemento Customer utilizando la clase XmlSchemaComplexType y la partícula de secuencia del tipo complejo utilizando la clase XmlSchemaSequence.
Agrega el nuevo elemento PhoneNumber a la secuencia que contiene los elementos FirstName y LastName existentes utilizando la colección Items previa a la compilación de esquemas de la secuencia.
Por último, vuelve a procesar y compilar el objeto XmlSchema modificado utilizando los métodos Reprocess y Compile de la clase XmlSchemaSet y lo escribe en la consola.
Éste es el ejemplo de código completo.
Imports System
Imports System.Xml
Imports System.Xml.Schema
Class XmlSchemaEditExample
Shared Sub Main()
' Add the customer schema to a new XmlSchemaSet and compile it.
' Any schema validation warnings and errors encountered reading or
' compiling the schema are handled by the ValidationEventHandler delegate.
Dim schemaSet As XmlSchemaSet = New XmlSchemaSet()
AddHandler schemaSet.ValidationEventHandler, AddressOf ValidationCallback
schemaSet.Add("http://www.tempuri.org", "customer.xsd")
schemaSet.Compile()
' Retrieve the compiled XmlSchema object from the XmlSchemaSet
' by iterating over the Schemas property.
Dim customerSchema As XmlSchema = Nothing
For Each schema As XmlSchema In schemaSet.Schemas()
customerSchema = schema
Next
' Create the PhoneNumber element.
Dim phoneElement As XmlSchemaElement = New XmlSchemaElement()
phoneElement.Name = "PhoneNumber"
' Create the xs:string simple type restriction.
Dim phoneType As XmlSchemaSimpleType = New XmlSchemaSimpleType()
Dim restriction As XmlSchemaSimpleTypeRestriction = _
New XmlSchemaSimpleTypeRestriction()
restriction.BaseTypeName = New XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema")
' Add a pattern facet to the restriction.
Dim phonePattern As XmlSchemaPatternFacet = New XmlSchemaPatternFacet()
phonePattern.Value = "\\d{3}-\\d{3}-\\d(4)"
restriction.Facets.Add(phonePattern)
' Add the restriction to the Content property of the simple type
' and the simple type to the SchemaType of the PhoneNumber element.
phoneType.Content = restriction
phoneElement.SchemaType = phoneType
' Iterate over each XmlSchemaElement in the Values collection
' of the Elements property.
For Each element As XmlSchemaElement In customerSchema.Elements.Values
' If the qualified name of the element is "Customer",
' get the complex type of the Customer element
' and the sequence particle of the complex type.
If element.QualifiedName.Name.Equals("Customer") Then
Dim customerType As XmlSchemaComplexType = _
CType(element.ElementSchemaType, XmlSchemaComplexType)
Dim sequence As XmlSchemaSequence = _
CType(customerType.Particle, XmlSchemaSequence)
' Add the new PhoneNumber element to the sequence.
sequence.Items.Add(phoneElement)
End If
Next
' Reprocess and compile the modified XmlSchema object and write it to the console.
schemaSet.Reprocess(customerSchema)
schemaSet.Compile()
customerSchema.Write(Console.Out)
End Sub
Shared Sub ValidationCallback(ByVal sender As Object, ByVal args As ValidationEventArgs)
If args.Severity = XmlSeverityType.Warning Then
Console.Write("WARNING: ")
Else
If args.Severity = XmlSeverityType.Error Then
Console.Write("ERROR: ")
End If
End If
Console.WriteLine(args.Message)
End Sub
End Class
using System;
using System.Xml;
using System.Xml.Schema;
class XmlSchemaEditExample
{
static void Main(string[] args)
{
// Add the customer schema to a new XmlSchemaSet and compile it.
// Any schema validation warnings and errors encountered reading or
// compiling the schema are handled by the ValidationEventHandler delegate.
XmlSchemaSet schemaSet = new XmlSchemaSet();
schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);
schemaSet.Add("http://www.tempuri.org", "customer.xsd");
schemaSet.Compile();
// Retrieve the compiled XmlSchema object from the XmlSchemaSet
// by iterating over the Schemas property.
XmlSchema customerSchema = null;
foreach (XmlSchema schema in schemaSet.Schemas())
{
customerSchema = schema;
}
// Create the PhoneNumber element.
XmlSchemaElement phoneElement = new XmlSchemaElement();
phoneElement.Name = "PhoneNumber";
// Create the xs:string simple type restriction.
XmlSchemaSimpleType phoneType = new XmlSchemaSimpleType();
XmlSchemaSimpleTypeRestriction restriction =
new XmlSchemaSimpleTypeRestriction();
restriction.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
// Add a pattern facet to the restriction.
XmlSchemaPatternFacet phonePattern = new XmlSchemaPatternFacet();
phonePattern.Value = "\\d{3}-\\d{3}-\\d(4)";
restriction.Facets.Add(phonePattern);
// Add the restriction to the Content property of the simple type
// and the simple type to the SchemaType of the PhoneNumber element.
phoneType.Content = restriction;
phoneElement.SchemaType = phoneType;
// Iterate over each XmlSchemaElement in the Values collection
// of the Elements property.
foreach (XmlSchemaElement element in customerSchema.Elements.Values)
{
// If the qualified name of the element is "Customer",
// get the complex type of the Customer element
// and the sequence particle of the complex type.
if (element.QualifiedName.Name.Equals("Customer"))
{
XmlSchemaComplexType customerType =
element.ElementSchemaType as XmlSchemaComplexType;
XmlSchemaSequence sequence =
customerType.Particle as XmlSchemaSequence;
// Add the new PhoneNumber element to the sequence.
sequence.Items.Add(phoneElement);
}
}
// Reprocess and compile the modified XmlSchema object and write it to the console.
schemaSet.Reprocess(customerSchema);
schemaSet.Compile();
customerSchema.Write(Console.Out);
}
static void ValidationCallback(object sender, ValidationEventArgs args)
{
if (args.Severity == XmlSeverityType.Warning)
Console.Write("WARNING: ");
else if (args.Severity == XmlSeverityType.Error)
Console.Write("ERROR: ");
Console.WriteLine(args.Message);
}
}
#using <System.Xml.dll>
using namespace System;
using namespace System::Xml;
using namespace System::Xml::Schema;
ref class XmlSchemaEditExample
{
public:
static void Main()
{
// Add the customer schema to a new XmlSchemaSet and compile it.
// Any schema validation warnings and errors encountered reading or
// compiling the schema are handled by the ValidationEventHandler delegate.
XmlSchemaSet^ schemaSet = gcnew XmlSchemaSet();
schemaSet->ValidationEventHandler += gcnew ValidationEventHandler(ValidationCallback);
schemaSet->Add("http://www.tempuri.org", "customer.xsd");
schemaSet->Compile();
// Retrieve the compiled XmlSchema object from the XmlSchemaSet
// by iterating over the Schemas property.
XmlSchema^ customerSchema = nullptr;
for each (XmlSchema^ schema in schemaSet->Schemas())
{
customerSchema = schema;
}
// Create the PhoneNumber element.
XmlSchemaElement^ phoneElement = gcnew XmlSchemaElement();
phoneElement->Name = "PhoneNumber";
// Create the xs:string simple type restriction.
XmlSchemaSimpleType^ phoneType = gcnew XmlSchemaSimpleType();
XmlSchemaSimpleTypeRestriction^ restriction =
gcnew XmlSchemaSimpleTypeRestriction();
restriction->BaseTypeName = gcnew XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
// Add a pattern facet to the restriction.
XmlSchemaPatternFacet^ phonePattern = gcnew XmlSchemaPatternFacet();
phonePattern->Value = "\\d{3}-\\d{3}-\\d(4)";
restriction->Facets->Add(phonePattern);
// Add the restriction to the Content property of the simple type
// and the simple type to the SchemaType of the PhoneNumber element.
phoneType->Content = restriction;
phoneElement->SchemaType = phoneType;
// Iterate over each XmlSchemaElement in the Values collection
// of the Elements property.
for each (XmlSchemaElement^ element in customerSchema->Elements->Values)
{
// If the qualified name of the element is "Customer",
// get the complex type of the Customer element
// and the sequence particle of the complex type.
if (element->QualifiedName->Name->Equals("Customer"))
{
XmlSchemaComplexType^ customerType =
dynamic_cast<XmlSchemaComplexType^>(element->ElementSchemaType);
XmlSchemaSequence^ sequence =
dynamic_cast<XmlSchemaSequence^>(customerType->Particle);
// Add the new PhoneNumber element to the sequence.
sequence->Items->Add(phoneElement);
}
}
// Reprocess and compile the modified XmlSchema object and write it to the console.
schemaSet->Reprocess(customerSchema);
schemaSet->Compile();
customerSchema->Write(Console::Out);
}
static void ValidationCallback(Object^ sender, ValidationEventArgs^ args)
{
if (args->Severity == XmlSeverityType::Warning)
Console::Write("WARNING: ");
else if (args->Severity == XmlSeverityType::Error)
Console::Write("ERROR: ");
Console::WriteLine(args->Message);
}
};
int main()
{
XmlSchemaEditExample::Main();
return 0;
}
A continuación se ofrece el esquema del cliente modificado que se creó en el tema Compilar esquemas XML.
<?xml version="1.0" encoding="utf-8"?>
<xs:schema xmlns:tns="http://www.tempuri.org" targetNamespace="http://www.tempuri.org" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="Customer">
<xs:complexType>
<xs:sequence>
<xs:element name="FirstName" type="xs:string" />
<xs:element name="LastName" type="tns:LastNameType" />
<xs:element name="PhoneNumber">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="\d{3}-\d{3}-\d(4)" />
</xs:restriction>
</xs:simpleType>
</xs:element>
</xs:sequence>
<xs:attribute name="CustomerId" type="xs:positiveInteger" use="required" /
>
</xs:complexType>
</xs:element>
<xs:simpleType name="LastNameType">
<xs:restriction base="xs:string">
<xs:maxLength value="20" />
</xs:restriction>
</xs:simpleType>
</xs:schema>
Ejemplo del atributo Title
En este segundo ejemplo de código se agrega un nuevo atributo Title al elemento FirstName del esquema del cliente. En el primer ejemplo de código el tipo del elemento FirstName es xs:string. Para que el elemento FirstName tenga un atributo junto con contenido de cadena, se debe cambiar su tipo por un tipo complejo con un modelo de contenido de extensión de contenido simple.
El ejemplo de código edita el esquema del cliente en los siguientes pasos.
Agrega el esquema del cliente a un objeto XmlSchemaSet nuevo y luego lo compila. Cualquier error o advertencia de validación de esquemas que se encuentre durante la lectura o compilación del esquema se controla por medio del delegado ValidationEventHandler.
Recupera el objeto XmlSchema compilado desde XmlSchemaSet iterando por la propiedad Schemas. Puesto que el esquema se compila, las propiedades del conjunto de información posterior a la compilación del esquema son accesibles.
Crea un nuevo tipo complejo del elemento FirstName utilizando la clase XmlSchemaComplexType.
Crea una nueva extensión de contenido simple con un tipo base de xs:string utilizando las clases XmlSchemaSimpleContent y XmlSchemaSimpleContentExtension.
Crea el nuevo atributo Title utilizando la clase XmlSchemaAttribute con un SchemaTypeName de xs:string y agrega el atributo a la extensión de contenido simple.
Establece el modelo de contenido del contenido simple en la extensión de contenido simple y el modelo de contenido del tipo simple en el contenido simple.
Agrega el nuevo tipo complejo a la colección XmlSchema.Items previa a la compilación de esquemas.
Itera por cada XmlSchemaObject en la colección XmlSchema.Items previa a la compilación de esquemas.
.gif "Nota") Nota |
|---|
Puesto que el elemento FirstName no es un elemento global del esquema, no está disponible en las colecciones XmlSchema.Items o XmlSchema.Elements.El ejemplo de código localiza el elemento FirstName, localizando primero el elemento Customer. El primer ejemplo de código atravesó el esquema utilizando la colección XmlSchema.Elements posterior a la compilación de esquemas.En este ejemplo se utiliza la colección XmlSchema.Items previa a la compilación de esquemas para atravesar el esquema.Aunque ambas colecciones proporcionan acceso a los elementos globales del esquema, la iteración por la colección Items tarda más tiempo porque hay que iterar por todos los elementos globales del esquema y no tiene ninguna propiedad PSCI.Las colecciones PSCI (XmlSchema.Elements, XmlSchema.Attributes, XmlSchema.SchemaTypes, etc.) proporcionan acceso directo a sus elementos, atributos y tipos globales y a sus propiedades PSCI. |
Si XmlSchemaObject es un elemento, cuyo QualifiedName es "Customer", se obtiene el tipo complejo del elemento Customer utilizando la clase XmlSchemaComplexType y la partícula de secuencia del tipo complejo utilizando la clase XmlSchemaSequence.
Itera por cada XmlSchemaParticle de la colección XmlSchemaSequence.Items previa a la compilación de esquemas.
Si XmlSchemaParticle es un elemento, cuyo QualifiedName es "FirstName", establece el SchemaTypeName del elemento FirstName en el nuevo tipo complejo FirstName.
Por último, vuelve a procesar y compilar el objeto XmlSchema modificado utilizando los métodos Reprocess y Compile de la clase XmlSchemaSet y lo escribe en la consola.
Éste es el ejemplo de código completo.
Imports System
Imports System.Xml
Imports System.Xml.Schema
Class XmlSchemaEditExample
Shared Sub Main()
' Add the customer schema to a new XmlSchemaSet and compile it.
' Any schema validation warnings and errors encountered reading or
' compiling the schema are handled by the ValidationEventHandler delegate.
Dim schemaSet As XmlSchemaSet = New XmlSchemaSet()
AddHandler schemaSet.ValidationEventHandler, AddressOf ValidationCallback
schemaSet.Add("http://www.tempuri.org", "customer.xsd")
schemaSet.Compile()
' Retrieve the compiled XmlSchema object from the XmlSchemaSet
' by iterating over the Schemas property.
Dim customerSchema As XmlSchema = Nothing
For Each schema As XmlSchema In schemaSet.Schemas()
customerSchema = schema
Next
' Create a complex type for the FirstName element.
Dim complexType As XmlSchemaComplexType = New XmlSchemaComplexType()
complexType.Name = "FirstNameComplexType"
' Create a simple content extension with a base type of xs:string.
Dim simpleContent As XmlSchemaSimpleContent = New XmlSchemaSimpleContent()
Dim simpleContentExtension As XmlSchemaSimpleContentExtension = _
New XmlSchemaSimpleContentExtension()
simpleContentExtension.BaseTypeName = _
New XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema")
' Create the new Title attribute with a SchemaTypeName of xs:string
' and add it to the simple content extension.
Dim attribute As XmlSchemaAttribute = New XmlSchemaAttribute()
attribute.Name = "Title"
attribute.SchemaTypeName = _
New XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema")
simpleContentExtension.Attributes.Add(attribute)
' Set the content model of the simple content to the simple content extension
' and the content model of the complex type to the simple content.
simpleContent.Content = simpleContentExtension
complexType.ContentModel = simpleContent
' Add the new complex type to the pre-schema-compilation Items collection.
customerSchema.Items.Add(complexType)
' Iterate over each XmlSchemaObject in the pre-schema-compilation
' Items collection.
For Each schemaObject As XmlSchemaObject In customerSchema.Items
' If the XmlSchemaObject is an element, whose QualifiedName
' is "Customer", get the complex type of the Customer element
' and the sequence particle of the complex type.
If schemaObject.GetType() Is GetType(XmlSchemaElement) Then
Dim element As XmlSchemaElement = CType(schemaObject, XmlSchemaElement)
If (element.QualifiedName.Name.Equals("Customer")) Then
Dim customerType As XmlSchemaComplexType = _
CType(element.ElementSchemaType, XmlSchemaComplexType)
Dim sequence As XmlSchemaSequence = _
CType(customerType.Particle, XmlSchemaSequence)
' Iterate over each XmlSchemaParticle in the pre-schema-compilation
' Items property.
For Each particle As XmlSchemaParticle In sequence.Items
' If the XmlSchemaParticle is an element, who's QualifiedName
' is "FirstName", set the SchemaTypeName of the FirstName element
' to the new FirstName complex type.
If particle.GetType() Is GetType(XmlSchemaElement) Then
Dim childElement As XmlSchemaElement = _
CType(particle, XmlSchemaElement)
If childElement.Name.Equals("FirstName") Then
childElement.SchemaTypeName = _
New XmlQualifiedName("FirstNameComplexType", _
"http://www.tempuri.org")
End If
End If
Next
End If
End If
Next
' Reprocess and compile the modified XmlSchema object and write it to the console.
schemaSet.Reprocess(customerSchema)
schemaSet.Compile()
customerSchema.Write(Console.Out)
End Sub
Shared Sub ValidationCallback(ByVal sender As Object, ByVal args As ValidationEventArgs)
If args.Severity = XmlSeverityType.Warning Then
Console.Write("WARNING: ")
Else
If args.Severity = XmlSeverityType.Error Then
Console.Write("ERROR: ")
End If
End If
Console.WriteLine(args.Message)
End Sub
End Class
using System;
using System.Xml;
using System.Xml.Schema;
class XmlSchemaEditExample
{
static void Main(string[] args)
{
// Add the customer schema to a new XmlSchemaSet and compile it.
// Any schema validation warnings and errors encountered reading or
// compiling the schema are handled by the ValidationEventHandler delegate.
XmlSchemaSet schemaSet = new XmlSchemaSet();
schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);
schemaSet.Add("http://www.tempuri.org", "customer.xsd");
schemaSet.Compile();
// Retrieve the compiled XmlSchema object from the XmlSchemaSet
// by iterating over the Schemas property.
XmlSchema customerSchema = null;
foreach (XmlSchema schema in schemaSet.Schemas())
{
customerSchema = schema;
}
// Create a complex type for the FirstName element.
XmlSchemaComplexType complexType = new XmlSchemaComplexType();
complexType.Name = "FirstNameComplexType";
// Create a simple content extension with a base type of xs:string.
XmlSchemaSimpleContent simpleContent = new XmlSchemaSimpleContent();
XmlSchemaSimpleContentExtension simpleContentExtension =
new XmlSchemaSimpleContentExtension();
simpleContentExtension.BaseTypeName =
new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
// Create the new Title attribute with a SchemaTypeName of xs:string
// and add it to the simple content extension.
XmlSchemaAttribute attribute = new XmlSchemaAttribute();
attribute.Name = "Title";
attribute.SchemaTypeName =
new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
simpleContentExtension.Attributes.Add(attribute);
// Set the content model of the simple content to the simple content extension
// and the content model of the complex type to the simple content.
simpleContent.Content = simpleContentExtension;
complexType.ContentModel = simpleContent;
// Add the new complex type to the pre-schema-compilation Items collection.
customerSchema.Items.Add(complexType);
// Iterate over each XmlSchemaObject in the pre-schema-compilation
// Items collection.
foreach (XmlSchemaObject schemaObject in customerSchema.Items)
{
// If the XmlSchemaObject is an element, whose QualifiedName
// is "Customer", get the complex type of the Customer element
// and the sequence particle of the complex type.
if (schemaObject is XmlSchemaElement)
{
XmlSchemaElement element = schemaObject as XmlSchemaElement;
if (element.QualifiedName.Name.Equals("Customer"))
{
XmlSchemaComplexType customerType =
element.ElementSchemaType as XmlSchemaComplexType;
XmlSchemaSequence sequence =
customerType.Particle as XmlSchemaSequence;
// Iterate over each XmlSchemaParticle in the pre-schema-compilation
// Items property.
foreach (XmlSchemaParticle particle in sequence.Items)
{
// If the XmlSchemaParticle is an element, who's QualifiedName
// is "FirstName", set the SchemaTypeName of the FirstName element
// to the new FirstName complex type.
if (particle is XmlSchemaElement)
{
XmlSchemaElement childElement =
particle as XmlSchemaElement;
if (childElement.Name.Equals("FirstName"))
{
childElement.SchemaTypeName =
new XmlQualifiedName("FirstNameComplexType",
"http://www.tempuri.org");
}
}
}
}
}
}
// Reprocess and compile the modified XmlSchema object and write it to the console.
schemaSet.Reprocess(customerSchema);
schemaSet.Compile();
customerSchema.Write(Console.Out);
}
static void ValidationCallback(object sender, ValidationEventArgs args)
{
if (args.Severity == XmlSeverityType.Warning)
Console.Write("WARNING: ");
else if (args.Severity == XmlSeverityType.Error)
Console.Write("ERROR: ");
Console.WriteLine(args.Message);
}
}
#using <System.Xml.dll>
using namespace System;
using namespace System::Xml;
using namespace System::Xml::Schema;
ref class XmlSchemaEditExample
{
public:
static void Main()
{
// Add the customer schema to a new XmlSchemaSet and compile it.
// Any schema validation warnings and errors encountered reading or
// compiling the schema are handled by the ValidationEventHandler delegate.
XmlSchemaSet^ schemaSet = gcnew XmlSchemaSet();
schemaSet->ValidationEventHandler += gcnew ValidationEventHandler(ValidationCallback);
schemaSet->Add("http://www.tempuri.org", "customer.xsd");
schemaSet->Compile();
// Retrieve the compiled XmlSchema object from the XmlSchemaSet
// by iterating over the Schemas property.
XmlSchema^ customerSchema = nullptr;
for each (XmlSchema^ schema in schemaSet->Schemas())
{
customerSchema = schema;
}
// Create a complex type for the FirstName element.
XmlSchemaComplexType^ complexType = gcnew XmlSchemaComplexType();
complexType->Name = "FirstNameComplexType";
// Create a simple content extension with a base type of xs:string.
XmlSchemaSimpleContent^ simpleContent = gcnew XmlSchemaSimpleContent();
XmlSchemaSimpleContentExtension^ simpleContentExtension =
gcnew XmlSchemaSimpleContentExtension();
simpleContentExtension->BaseTypeName =
gcnew XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
// Create the new Title attribute with a SchemaTypeName of xs:string
// and add it to the simple content extension.
XmlSchemaAttribute^ attribute = gcnew XmlSchemaAttribute();
attribute->Name = "Title";
attribute->SchemaTypeName =
gcnew XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
simpleContentExtension->Attributes->Add(attribute);
// Set the content model of the simple content to the simple content extension
// and the content model of the complex type to the simple content.
simpleContent->Content = simpleContentExtension;
complexType->ContentModel = simpleContent;
// Add the new complex type to the pre-schema-compilation Items collection.
customerSchema->Items->Add(complexType);
// Iterate over each XmlSchemaObject in the pre-schema-compilation
// Items collection.
for each (XmlSchemaObject^ schemaObject in customerSchema->Items)
{
// If the XmlSchemaObject is an element, whose QualifiedName
// is "Customer", get the complex type of the Customer element
// and the sequence particle of the complex type.
if (schemaObject::typeid == XmlSchemaElement::typeid)
{
XmlSchemaElement^ element = dynamic_cast<XmlSchemaElement^>(schemaObject);
if (element->QualifiedName->Name->Equals("Customer"))
{
XmlSchemaComplexType^ customerType =
dynamic_cast<XmlSchemaComplexType^>(element->ElementSchemaType);
XmlSchemaSequence^ sequence =
dynamic_cast<XmlSchemaSequence^>(customerType->Particle);
// Iterate over each XmlSchemaParticle in the pre-schema-compilation
// Items property.
for each (XmlSchemaParticle^ particle in sequence->Items)
{
// If the XmlSchemaParticle is an element, who's QualifiedName
// is "FirstName", set the SchemaTypeName of the FirstName element
// to the new FirstName complex type.
if (particle::typeid == XmlSchemaElement::typeid)
{
XmlSchemaElement^ childElement =
dynamic_cast<XmlSchemaElement^>(particle);
if (childElement->Name->Equals("FirstName"))
{
childElement->SchemaTypeName =
gcnew XmlQualifiedName("FirstNameComplexType",
"http://www.tempuri.org");
}
}
}
}
}
}
// Reprocess and compile the modified XmlSchema object and write it to the console.
schemaSet->Reprocess(customerSchema);
schemaSet->Compile();
customerSchema->Write(Console::Out);
}
static void ValidationCallback(Object^ sender, ValidationEventArgs^ args)
{
if (args->Severity == XmlSeverityType::Warning)
Console::Write("WARNING: ");
else if (args->Severity == XmlSeverityType::Error)
Console::Write("ERROR: ");
Console::WriteLine(args->Message);
}
};
int main()
{
XmlSchemaEditExample::Main();
return 0;
}
A continuación se ofrece el esquema del cliente modificado que se creó en el tema Compilar esquemas XML.
<?xml version="1.0" encoding=" utf-8"?>
<xs:schema xmlns:tns="http://www.tempuri.org" targetNamespace="http://www.tempuri.org" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="Customer">
<xs:complexType>
<xs:sequence>
<xs:element name="FirstName" type="tns:FirstNameComplexType" />
<xs:element name="LastName" type="tns:LastNameType" />
</xs:sequence>
<xs:attribute name="CustomerId" type="xs:positiveInteger" use="required" /
>
</xs:complexType>
</xs:element>
<xs:simpleType name="LastNameType">
<xs:restriction base="xs:string">
<xs:maxLength value="20" />
</xs:restriction>
</xs:simpleType>
<xs:complexType name="FirstNameComplexType">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="Title" type="xs:string" />
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:schema>
Vea también
Conceptos
Información general sobre el Modelo de objetos de esquema XML
Lectura y escritura de esquemas XML
Inclusión o importación de esquemas XML
XmlSchemaSet para compilación de esquemas
Conjunto de información posterior a la compilación de esquemas