Inclusion ou importation de schémas XML
Un schéma XML peut contenir des éléments <xs:import />, <xs:include /> et <xs:redefine />. Ces éléments de schéma réfèrent à d'autres schémas XML qui peuvent être utilisés pour compléter la structure du schéma où ils sont inclus ou importés. Les classes XmlSchemaImport, XmlSchemaInclude et XmlSchemaRedefine sont mappées à ces éléments dans l'API SOM (Schema Object Model).
Inclusion ou importation d'un schéma XML
L'exemple de code suivant complète le schéma utilisateur créé dans la rubrique Création de schémas XML avec le schéma d'adresse. Cette opération rend les types d'adresses disponibles dans le schéma utilisateur.
Le schéma d'adresse peut être incorporé à l'aide d'éléments <xs:include /> ou <xs:import /> pour utiliser les composants du schéma d'adresse tels quels, ou à l'aide d'un élément <xs:redefine /> pour modifier l'un quelconque de ses composants en fonction des besoins du schéma utilisateur. Le schéma d'adresse ayant un targetNamespace différent de celui du schéma utilisateur, on utilise l'élément <xs:import /> et donc la sémantique d'importation.
L'exemple de code inclut le schéma d'adresse en plusieurs étapes comme suit.
Il ajoute le schéma utilisateur et le schéma d'adresse à un nouvel objet XmlSchemaSet puis les compile. Les avertissements et erreurs de validation de schéma éventuellement rencontrés pendant la lecture ou la compilation des schémas sont traités par le délégué ValidationEventHandler.
Il extrait les objets XmlSchema compilés, tant pour le schéma utilisateur que pour le schéma d'adresse, de l'objet XmlSchemaSet en effectuant une itération sur la propriété Schemas. Les schémas étant compilés, les propriétés PSCI (Post-Schema-Compilation-Infoset) sont accessibles.
Il crée un objet XmlSchemaImport, définit la propriété Namespace de l'importation comme étant l'espace de noms du schéma d'adresse, définit la propriété Schema de l'importation comme étant l'objet XmlSchema du schéma d'adresse et ajoute l'importation à la propriété Includes du schéma utilisateur.
Il retraite et compile l'objet XmlSchema modifié du schéma utilisateur à l'aide des méthodes Reprocess et Compile de la classe XmlSchemaSet et écrit le résultat à la console.
Enfin, de manière récursive, il écrit à la console tous les schémas importés dans le schéma utilisateur en utilisant la propriété Includes du schéma utilisateur. La propriété Includes fournit l'accès à toutes les inclusions, importations ou redéfinitions ajoutées à un schéma.
Voici l'exemple de code complet et les schémas utilisateur et d'adresse écrits à la console.
Imports System
Imports System.Xml
Imports System.Xml.Schema
Class XmlSchemaImportExample
Shared Sub Main()
' Add the customer and address schemas to a new XmlSchemaSet and compile them.
' Any schema validation warnings and errors encountered reading or
' compiling the schemas 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.Add("http://www.example.com/IPO", "address.xsd")
schemaSet.Compile()
' Retrieve the compiled XmlSchema objects for the customer and
' address schema from the XmlSchemaSet by iterating over
' the Schemas property.
Dim customerSchema As XmlSchema = Nothing
Dim addressSchema As XmlSchema = Nothing
For Each schema As XmlSchema In schemaSet.Schemas()
If schema.TargetNamespace = "http://www.tempuri.org" Then
customerSchema = schema
ElseIf schema.TargetNamespace = "http://www.example.com/IPO" Then
addressSchema = schema
End If
Next
' Create an XmlSchemaImport object, set the Namespace property
' to the namespace of the address schema, the Schema property
' to the address schema, and add it to the Includes property
' of the customer schema.
Dim import As XmlSchemaImport = New XmlSchemaImport()
import.Namespace = "http://www.example.com/IPO"
import.Schema = addressSchema
customerSchema.Includes.Add(import)
' Reprocess and compile the modified XmlSchema object
' of the customer schema and write it to the console.
schemaSet.Reprocess(customerSchema)
schemaSet.Compile()
customerSchema.Write(Console.Out)
' Recursively write all of the schemas imported into the
' customer schema to the console using the Includes
' property of the customer schema.
RecurseExternals(customerSchema)
End Sub
Shared Sub RecurseExternals(ByVal schema As XmlSchema)
For Each external As XmlSchemaExternal In Schema.Includes
If Not external.SchemaLocation = Nothing Then
Console.WriteLine("External SchemaLocation: {0}", external.SchemaLocation)
End If
If external.GetType() Is GetType(XmlSchemaImport) Then
Dim import As XmlSchemaImport = CType(external, XmlSchemaImport)
Console.WriteLine("Imported namespace: {0}", import.Namespace)
End If
If Not external.Schema Is Nothing Then
external.Schema.Write(Console.Out)
RecurseExternals(external.Schema)
End If
Next
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 XmlSchemaImportExample
{
static void Main(string[] args)
{
// Add the customer and address schemas to a new XmlSchemaSet and compile them.
// Any schema validation warnings and errors encountered reading or
// compiling the schemas are handled by the ValidationEventHandler delegate.
XmlSchemaSet schemaSet = new XmlSchemaSet();
schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);
schemaSet.Add("http://www.tempuri.org", "customer.xsd");
schemaSet.Add("http://www.example.com/IPO", "address.xsd");
schemaSet.Compile();
// Retrieve the compiled XmlSchema objects for the customer and
// address schema from the XmlSchemaSet by iterating over
// the Schemas property.
XmlSchema customerSchema = null;
XmlSchema addressSchema = null;
foreach (XmlSchema schema in schemaSet.Schemas())
{
if (schema.TargetNamespace == "http://www.tempuri.org")
customerSchema = schema;
else if (schema.TargetNamespace == "http://www.example.com/IPO")
addressSchema = schema;
}
// Create an XmlSchemaImport object, set the Namespace property
// to the namespace of the address schema, the Schema property
// to the address schema, and add it to the Includes property
// of the customer schema.
XmlSchemaImport import = new XmlSchemaImport();
import.Namespace = "http://www.example.com/IPO";
import.Schema = addressSchema;
customerSchema.Includes.Add(import);
// Reprocess and compile the modified XmlSchema object
// of the customer schema and write it to the console.
schemaSet.Reprocess(customerSchema);
schemaSet.Compile();
customerSchema.Write(Console.Out);
// Recursively write all of the schemas imported into the
// customer schema to the console using the Includes
// property of the customer schema.
RecurseExternals(customerSchema);
}
static void RecurseExternals(XmlSchema schema)
{
foreach (XmlSchemaExternal external in schema.Includes)
{
if (external.SchemaLocation != null)
{
Console.WriteLine("External SchemaLocation: {0}", external.SchemaLocation);
}
if (external is XmlSchemaImport)
{
XmlSchemaImport import = external as XmlSchemaImport;
Console.WriteLine("Imported namespace: {0}", import.Namespace);
}
if (external.Schema != null)
{
external.Schema.Write(Console.Out);
RecurseExternals(external.Schema);
}
}
}
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 XmlSchemaImportExample
{
public:
static void Main()
{
// Add the customer and address schemas to a new XmlSchemaSet and compile them.
// Any schema validation warnings and errors encountered reading or
// compiling the schemas are handled by the ValidationEventHandler delegate.
XmlSchemaSet^ schemaSet = gcnew XmlSchemaSet();
schemaSet->ValidationEventHandler += gcnew ValidationEventHandler(ValidationCallback);
schemaSet->Add("http://www.tempuri.org", "customer.xsd");
schemaSet->Add("http://www.example.com/IPO", "address.xsd");
schemaSet->Compile();
// Retrieve the compiled XmlSchema objects for the customer and
// address schema from the XmlSchemaSet by iterating over
// the Schemas property.
XmlSchema^ customerSchema = nullptr;
XmlSchema^ addressSchema = nullptr;
for each (XmlSchema^ schema in schemaSet->Schemas())
{
if (schema->TargetNamespace == "http://www.tempuri.org")
customerSchema = schema;
else if (schema->TargetNamespace == "http://www.example.com/IPO")
addressSchema = schema;
}
// Create an XmlSchemaImport object, set the Namespace property
// to the namespace of the address schema, the Schema property
// to the address schema, and add it to the Includes property
// of the customer schema.
XmlSchemaImport^ import = gcnew XmlSchemaImport();
import->Namespace = "http://www.example.com/IPO";
import->Schema = addressSchema;
customerSchema->Includes->Add(import);
// Reprocess and compile the modified XmlSchema object
// of the customer schema and write it to the console.
schemaSet->Reprocess(customerSchema);
schemaSet->Compile();
customerSchema->Write(Console::Out);
// Recursively write all of the schemas imported into the
// customer schema to the console using the Includes
// property of the customer schema.
RecurseExternals(customerSchema);
}
static void RecurseExternals(XmlSchema^ schema)
{
for each (XmlSchemaExternal^ external in schema->Includes)
{
if (external->SchemaLocation != nullptr)
{
Console::WriteLine("External SchemaLocation: {0}", external->SchemaLocation);
}
if (external::typeid == XmlSchemaImport::typeid)
{
XmlSchemaImport^ import = dynamic_cast<XmlSchemaImport^>(external);
Console::WriteLine("Imported namespace: {0}", import->Namespace);
}
if (external->Schema != nullptr)
{
external->Schema->Write(Console::Out);
RecurseExternals(external->Schema);
}
}
}
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()
{
XmlSchemaImportExample::Main();
return 0;
}
<?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:import namespace="http://www.example.com/IPO" />
<xs:element name="Customer">
<xs:complexType>
<xs:sequence>
<xs:element name="FirstName" type="xs:string" />
<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:schema>
<schema targetNamespace="http://www.example.com/IPO" xmlns="http://www.w3.org/2001/XMLSchema" xmlns:ipo="http://www.example.com/IPO">
<annotation>
<documentation xml:lang="en">
Addresses for International Purchase order schema
Copyright 2000 Example.com. All rights reserved.
</documentation>
</annotation>
<complexType name="Address">
<sequence>
<element name="name" type="string"/>
<element name="street" type="string"/>
<element name="city" type="string"/>
</sequence>
</complexType>
<complexType name="USAddress">
<complexContent>
<extension base="ipo:Address">
<sequence>
<element name="state" type="ipo:USState"/>
<element name="zip" type="positiveInteger"/>
</sequence>
</extension>
</complexContent>
</complexType>
<!-- other Address derivations for more countries or regions -->
<simpleType name="USState">
<restriction base="string">
<enumeration value="AK"/>
<enumeration value="AL"/>
<enumeration value="AR"/>
<!-- and so on ... -->
</restriction>
</simpleType>
</schema>
Pour plus d'informations sur les éléments <xs:import />, <xs:include /> et <xs:redefine />, ainsi que sur les classes XmlSchemaImport, XmlSchemaInclude et XmlSchemaRedefine, consultez W3C XML Schema (en anglais) et la documentation de référence de la classe d'espace de noms System.Xml.Schema.
Voir aussi
Concepts
Vue d'ensemble du Modèle Objet du schéma XML