Úpravy schémat XML
Úprava schématu XML je jednou z nejdůležitějších funkcí modelu objektu schématu (SOM). Všechny vlastnosti předběžné kompilace schématu SOM lze použít ke změně existujících hodnot ve schématu XML. Schéma XML je pak možné znovu zkompilovat tak, aby odráželo změny.
Prvním krokem při úpravě schématu načteného do SOM je procházení schématu. Než se pokusíte upravit schéma, měli byste být obeznámeni s procházením schématu pomocí rozhraní API SOM. Měli byste být také obeznámeni s vlastnostmi předběžné kompilace a po vytvoření schématu sady PSCI (Post-Schema-Compilation-Infoset).
Úprava schématu XML
V této části jsou k dispozici dva příklady kódu, z nichž obě upravují schéma zákazníka vytvořené v tématu Vytváření schémat XML. První příklad kódu přidá do elementu Customer nový PhoneNumber prvek a druhý příklad kódu přidá do elementu FirstName nový Title atribut. První ukázka také používá kolekci po kompilaci XmlSchema.Elements schématu jako prostředek procházení schématu zákazníka, zatímco druhý příklad kódu používá kolekci před kompilací XmlSchema.Items schématu.
Příklad elementu Telefon Number
Tento první příklad kódu přidá nový PhoneNumber prvek do Customer elementu schématu zákazníka. Příklad kódu upraví schéma zákazníka v následujících krocích.
Přidá schéma zákazníka do nového XmlSchemaSet objektu a pak ho zkompiluje. Delegát zpracovává všechna upozornění na ověření schématu a chyby, ke kterým došlo při čtení nebo kompilaci schématu ValidationEventHandler .
Načte zkompilovaný XmlSchema objekt XmlSchemaSet iterací přes Schemas vlastnost. Vzhledem k tomu, že je schéma zkompilováno, jsou vlastnosti Post-Schema-Compilation-Infoset (PSCI) přístupné.
PhoneNumberVytvoří prvek pomocí XmlSchemaElement třídy,xs:stringjednoduché omezení typu pomocí XmlSchemaSimpleType a XmlSchemaSimpleTypeRestriction třídy, přidá vzor omezující vlastnost omezení Facets a přidá omezení do Content vlastnosti jednoduchého typu a jednoduchý typ elementu SchemaTypePhoneNumber.Iteruje každý XmlSchemaElement v Values kolekci kolekce po kompilaci XmlSchema.Elements schématu.
QualifiedName Pokud je
"Customer"prvek , získá komplexní typCustomerprvku pomocí XmlSchemaComplexType třídy a sekvence částice komplexního typu pomocí XmlSchemaSequence třídy.Přidá nový
PhoneNumberprvek do sekvence obsahující existujícíFirstNameprvky aLastNameprvky pomocí kolekce před kompilací Items schématu sekvence.Nakonec reprocesuje a zkompiluje upravený XmlSchema objekt pomocí Reprocess a Compile metod XmlSchemaSet třídy a zapíše ho do konzoly.
Následuje kompletní příklad kódu.
#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;
}
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);
}
}
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
Toto je upravené schéma zákazníka vytvořené v tématu Vytváření schémat 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>
Příklad atributu Title
Tento druhý příklad kódu přidá nový Title atribut do FirstName elementu schématu zákazníka. V prvním příkladu kódu je typ elementu FirstNamexs:string. FirstName Aby prvek měl atribut spolu s obsahem řetězce, musí být jeho typ změněn na komplexní typ s jednoduchým rozšířením obsahu con režim stanu l.
Příklad kódu upraví schéma zákazníka v následujících krocích.
Přidá schéma zákazníka do nového XmlSchemaSet objektu a pak ho zkompiluje. Delegát zpracovává všechna upozornění na ověření schématu a chyby, ke kterým došlo při čtení nebo kompilaci schématu ValidationEventHandler .
Načte zkompilovaný XmlSchema objekt XmlSchemaSet iterací přes Schemas vlastnost. Vzhledem k tomu, že je schéma zkompilováno, jsou vlastnosti Post-Schema-Compilation-Infoset (PSCI) přístupné.
Vytvoří nový komplexní typ prvku
FirstNamepomocí XmlSchemaComplexType třídy.Vytvoří nové jednoduché rozšíření obsahu se základním typem
xs:string, pomocí a XmlSchemaSimpleContentXmlSchemaSimpleContentExtension třídy.Vytvoří nový
Titleatribut pomocí XmlSchemaAttribute třídy s příponou SchemaTypeNamexs:stringa přidá atribut do jednoduchého rozšíření obsahu.Nastaví kon režim stanu l jednoduchého obsahu na jednoduché rozšíření obsahu a con režim stanu l komplexního typu na jednoduchý obsah.
Přidá nový komplexní typ do kolekce před kompilací XmlSchema.Items schématu.
Iteruje každý XmlSchemaObject v kolekci před kompilací XmlSchema.Items schématu.
Poznámka:
FirstName Vzhledem k tomu, že prvek není globálním prvkem ve schématu, není k dispozici v XmlSchema.Items kolekcích ani XmlSchema.Elements v kolekcích. Příklad kódu vyhledá FirstName prvek tak, že nejprve vyhledá Customer element.
První příklad kódu prochází schéma pomocí kolekce post-schema-compilation XmlSchema.Elements . V této ukázce se kolekce před kompilací XmlSchema.Items schématu používá k procházení schématu. I když obě kolekce poskytují přístup ke globálním prvkům ve schématu, iterace prostřednictvím Items kolekce je časově náročná, protože musíte iterovat nad všemi globálními prvky ve schématu a nemá žádné vlastnosti PSCI. Kolekce PSCI (XmlSchema.Elements, XmlSchema.Attributes, XmlSchema.SchemaTypesa tak dále) poskytují přímý přístup ke svým globálním prvkům, atributům a typům a jejich vlastnostem PSCI.
Je-li XmlSchemaObject prvek, jehož QualifiedName je
"Customer", získá komplexní typCustomerprvku pomocí XmlSchemaComplexType třídy a sekvence částice komplexního typu pomocí XmlSchemaSequence třídy.Iteruje každý XmlSchemaParticle v kolekci před kompilací XmlSchemaSequence.Items schématu.
XmlSchemaParticle Pokud je prvek, který QualifiedName je
"FirstName", nastaví SchemaTypeNameFirstNameprvek na novýFirstNamekomplexní typ.Nakonec reprocesuje a zkompiluje upravený XmlSchema objekt pomocí Reprocess a Compile metod XmlSchemaSet třídy a zapíše ho do konzoly.
Následuje kompletní příklad kódu.
#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;
}
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);
}
}
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
Toto je upravené schéma zákazníka vytvořené v tématu Vytváření schémat 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>
