Partager via


XmlSchema Classe

Définition

Représentation en mémoire d’un schéma XML, comme indiqué dans les spécifications World Wide Web Consortium (W3C) XML Schema Part 1: Structures et XML Schema Part 2: Datatypes].

public ref class XmlSchema
public ref class XmlSchema : System::Xml::Schema::XmlSchemaObject
public class XmlSchema
public class XmlSchema : System.Xml.Schema.XmlSchemaObject
type XmlSchema = class
type XmlSchema = class
    inherit XmlSchemaObject
Public Class XmlSchema
Public Class XmlSchema
Inherits XmlSchemaObject
Héritage
XmlSchema
Héritage

Exemples

L’exemple suivant crée une définition de schéma.

#using <mscorlib.dll>
#using <System.Xml.dll>

using namespace System;
using namespace System::Xml;
using namespace System::Xml::Schema;

class XmlSchemaExamples
{
public:
    static void Main()
    {

        XmlSchema^ schema = gcnew XmlSchema();

        // <xs:element name="cat" type="xs:string"/>
        XmlSchemaElement^ elementCat = gcnew XmlSchemaElement();
        schema->Items->Add(elementCat);
        elementCat->Name = "cat";
        elementCat->SchemaTypeName = gcnew XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");

        // <xs:element name="dog" type="xs:string"/>
        XmlSchemaElement^ elementDog = gcnew XmlSchemaElement();
        schema->Items->Add(elementDog);
        elementDog->Name = "dog";
        elementDog->SchemaTypeName = gcnew XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");

        // <xs:element name="redDog" substitutionGroup="dog" />
        XmlSchemaElement^ elementRedDog = gcnew XmlSchemaElement();
        schema->Items->Add(elementRedDog);
        elementRedDog->Name = "redDog";
        elementRedDog->SubstitutionGroup = gcnew XmlQualifiedName("dog");

        // <xs:element name="brownDog" substitutionGroup ="dog" />
        XmlSchemaElement^ elementBrownDog = gcnew XmlSchemaElement();
        schema->Items->Add(elementBrownDog);
        elementBrownDog->Name = "brownDog";
        elementBrownDog->SubstitutionGroup = gcnew XmlQualifiedName("dog");


        // <xs:element name="pets">
        XmlSchemaElement^ elementPets = gcnew XmlSchemaElement();
        schema->Items->Add(elementPets);
        elementPets->Name = "pets";

        // <xs:complexType>
        XmlSchemaComplexType^ complexType = gcnew XmlSchemaComplexType();
        elementPets->SchemaType = complexType;

        // <xs:choice minOccurs="0" maxOccurs="unbounded">
        XmlSchemaChoice^ choice = gcnew XmlSchemaChoice();
        complexType->Particle = choice;
        choice->MinOccurs = 0;
        choice->MaxOccursString = "unbounded";

        // <xs:element ref="cat"/>
        XmlSchemaElement^ catRef = gcnew XmlSchemaElement();
        choice->Items->Add(catRef);
        catRef->RefName = gcnew XmlQualifiedName("cat");

        // <xs:element ref="dog"/>
        XmlSchemaElement^ dogRef = gcnew XmlSchemaElement();
        choice->Items->Add(dogRef);
        dogRef->RefName = gcnew XmlQualifiedName("dog");

        XmlSchemaSet^ schemaSet = gcnew XmlSchemaSet();
        schemaSet->ValidationEventHandler += gcnew ValidationEventHandler(ValidationCallbackOne);
        schemaSet->Add(schema);
        schemaSet->Compile();

        XmlSchema^ compiledSchema;

        for each (XmlSchema^ schema1 in schemaSet->Schemas())
        {
            compiledSchema = schema1;
        }

        XmlNamespaceManager^ nsmgr = gcnew XmlNamespaceManager(gcnew NameTable());
        nsmgr->AddNamespace("xs", "http://www.w3.org/2001/XMLSchema");
        compiledSchema->Write(Console::Out, nsmgr);
    }

    static void ValidationCallbackOne(Object^ sender, ValidationEventArgs^ args)
    {
        Console::WriteLine(args->Message);
    }
};

int main()
{
    XmlSchemaExamples::Main();
    return 0;
};
using System;
using System.Xml;
using System.Xml.Schema;

class XMLSchemaExamples
{
    public static void Main()
    {

        XmlSchema schema = new XmlSchema();

        // <xs:element name="cat" type="xs:string"/>
        XmlSchemaElement elementCat = new XmlSchemaElement();
        schema.Items.Add(elementCat);
        elementCat.Name = "cat";
        elementCat.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");

        // <xs:element name="dog" type="xs:string"/>
        XmlSchemaElement elementDog = new XmlSchemaElement();
        schema.Items.Add(elementDog);
        elementDog.Name = "dog";
        elementDog.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");

        // <xs:element name="redDog" substitutionGroup="dog" />
        XmlSchemaElement elementRedDog = new XmlSchemaElement();
        schema.Items.Add(elementRedDog);
        elementRedDog.Name = "redDog";
        elementRedDog.SubstitutionGroup = new XmlQualifiedName("dog");

        // <xs:element name="brownDog" substitutionGroup ="dog" />
        XmlSchemaElement elementBrownDog = new XmlSchemaElement();
        schema.Items.Add(elementBrownDog);
        elementBrownDog.Name = "brownDog";
        elementBrownDog.SubstitutionGroup = new XmlQualifiedName("dog");

        // <xs:element name="pets">
        XmlSchemaElement elementPets = new XmlSchemaElement();
        schema.Items.Add(elementPets);
        elementPets.Name = "pets";

        // <xs:complexType>
        XmlSchemaComplexType complexType = new XmlSchemaComplexType();
        elementPets.SchemaType = complexType;

        // <xs:choice minOccurs="0" maxOccurs="unbounded">
        XmlSchemaChoice choice = new XmlSchemaChoice();
        complexType.Particle = choice;
        choice.MinOccurs = 0;
        choice.MaxOccursString = "unbounded";

        // <xs:element ref="cat"/>
        XmlSchemaElement catRef = new XmlSchemaElement();
        choice.Items.Add(catRef);
        catRef.RefName = new XmlQualifiedName("cat");

        // <xs:element ref="dog"/>
        XmlSchemaElement dogRef = new XmlSchemaElement();
        choice.Items.Add(dogRef);
        dogRef.RefName = new XmlQualifiedName("dog");

        XmlSchemaSet schemaSet = new XmlSchemaSet();
        schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallbackOne);
        schemaSet.Add(schema);
        schemaSet.Compile();

        XmlSchema compiledSchema = null;

        foreach (XmlSchema schema1 in schemaSet.Schemas())
        {
            compiledSchema = schema1;
        }

        XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());
        nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema");
        compiledSchema.Write(Console.Out, nsmgr);
    }

    public static void ValidationCallbackOne(object sender, ValidationEventArgs args)
    {
        Console.WriteLine(args.Message);
    }
}
Option Explicit On
Option Strict On

Imports System.Xml
Imports System.Xml.Schema

Class XMLSchemaExamples
    Public Shared Sub Main()
        Dim schema As New XmlSchema()

        ' <xs:element name="cat" type="xs:string"/>
        Dim elementCat As New XmlSchemaElement()
        schema.Items.Add(elementCat)
        elementCat.Name = "cat"
        elementCat.SchemaTypeName = New XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema")

        ' <xs:element name="dog" type="xs:string"/>
        Dim elementDog As New XmlSchemaElement()
        schema.Items.Add(elementDog)
        elementDog.Name = "dog"
        elementDog.SchemaTypeName = New XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema")

        ' <xs:element name="redDog" substitutionGroup="dog" />
        Dim elementRedDog As New XmlSchemaElement()
        schema.Items.Add(elementRedDog)
        elementRedDog.Name = "redDog"
        elementRedDog.SubstitutionGroup = New XmlQualifiedName("dog")

        ' <xs:element name="brownDog" substitutionGroup ="dog" />
        Dim elementBrownDog As New XmlSchemaElement()
        schema.Items.Add(elementBrownDog)
        elementBrownDog.Name = "brownDog"
        elementBrownDog.SubstitutionGroup = New XmlQualifiedName("dog")

        ' <xs:element name="pets">
        Dim elementPets As New XmlSchemaElement()
        schema.Items.Add(elementPets)
        elementPets.Name = "pets"

        ' <xs:complexType>
        Dim complexType As New XmlSchemaComplexType()
        elementPets.SchemaType = complexType

        ' <xs:choice minOccurs="0" maxOccurs="unbounded">
        Dim choice As New XmlSchemaChoice()
        complexType.Particle = choice
        choice.MinOccurs = 0
        choice.MaxOccursString = "unbounded"

        ' <xs:element ref="cat"/>
        Dim catRef As New XmlSchemaElement()
        choice.Items.Add(catRef)
        catRef.RefName = New XmlQualifiedName("cat")

        ' <xs:element ref="dog"/>
        Dim dogRef As New XmlSchemaElement()
        choice.Items.Add(dogRef)
        dogRef.RefName = New XmlQualifiedName("dog")

        Dim schemaSet As New XmlSchemaSet()
        AddHandler schemaSet.ValidationEventHandler, AddressOf ValidationCallbackOne

        schemaSet.Add(schema)
        schemaSet.Compile()

        Dim compiledSchema As XmlSchema = Nothing

        For Each schema1 As XmlSchema In schemaSet.Schemas()
            compiledSchema = schema1
        Next

        Dim nsmgr As New XmlNamespaceManager(New NameTable())
        nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema")
        compiledSchema.Write(Console.Out, nsmgr)


    End Sub


    Public Shared Sub ValidationCallbackOne(ByVal sender As Object, ByVal args As ValidationEventArgs)
        Console.WriteLine(args.Message)
    End Sub
End Class

Le fichier XML suivant est généré pour l’exemple de code précédent.


<?xml version="1.0" encoding="IBM437"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="cat" type="xs:string"/>
    <xs:element name="dog" type="xs:string"/>
    <xs:element name="redDog" type="xs:string" substitutionGroup="dog"/>
    <xs:element name="brownDog" type="xs:string" substitutionGroup ="dog" />

    <xs:element name="pets">
      <xs:complexType>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="cat"/>
          <xs:element ref="dog"/>
        </xs:choice>
      </xs:complexType>
    </xs:element>
</xs:schema>

Remarques

Important

  • N’utilisez pas de schémas provenant de sources ou d’emplacements inconnus ou non approuvés. Cela compromettra la sécurité de votre code.
  • Les schémas XML (y compris les schémas inline) sont intrinsèquement vulnérables aux attaques par déni de service ; ne les acceptez pas dans des scénarios non approuvés.
  • Les exceptions levées suite à l’utilisation de la XmlSchema classe, telles que la XmlSchemaException classe, peuvent contenir des informations sensibles qui ne doivent pas être exposées dans des scénarios non approuvés. Par exemple, la SourceUri propriété d’un retourne le chemin d’URI XmlSchemaException au fichier de schéma à l’origine de l’exception. La SourceUri propriété ne doit pas être exposée dans des scénarios non approuvés. Les exceptions doivent être correctement gérées afin que ces informations sensibles ne soient pas exposées dans des scénarios non approuvés.

Constructeurs

XmlSchema()

Initialise une nouvelle instance de la classe XmlSchema.

Champs

InstanceNamespace

Espace de noms de l'instance du schéma XML. Ce champ est constant.

Namespace

Espace de noms du schéma XML. Ce champ est constant.

Propriétés

AttributeFormDefault

Obtient ou définit le formulaire pour les attributs déclarés de l'espace de noms cible du schéma.

AttributeGroups

Obtient la valeur postérieure à la compilation du schéma de tous les groupes d'attributs globaux du schéma.

Attributes

Obtient la valeur postérieure à la compilation du schéma pour tous les attributs du schéma.

BlockDefault

Obtient ou définit l'attribut blockDefault qui définit la valeur par défaut de l'attribut block sur l'élément et les types complexes dans le targetNamespace du schéma.

ElementFormDefault

Obtient ou définit le formulaire pour les éléments déclarés de l'espace de noms cible du schéma.

Elements

Obtient la valeur postérieure à la compilation du schéma pour tous les éléments du schéma.

FinalDefault

Obtient ou définit l'attribut finalDefault qui définit la valeur par défaut de l'attribut final sur les éléments et les types complexes dans l'espace de noms cible du schéma.

Groups

Obtient la valeur postérieure à la compilation du schéma pour tous les groupes du schéma.

Id

Obtient ou définit l'ID de la chaîne.

Includes

Obtient la collection de schémas inclus et importés.

IsCompiled

Indique si le schéma a été compilé.

Items

Obtient la collection d'éléments de schéma dans le schéma et est utilisé pour ajouter de nouveaux types d'élément au niveau de l'élément schema.

LineNumber

Obtient ou définit le numéro de la ligne du fichier à laquelle l'élément schema fait référence.

(Hérité de XmlSchemaObject)
LinePosition

Obtient ou définit la position de la ligne du fichier à laquelle l'élément schema fait référence.

(Hérité de XmlSchemaObject)
Namespaces

Obtient ou définit le XmlSerializerNamespaces à utiliser avec cet objet de schéma.

(Hérité de XmlSchemaObject)
Notations

Obtient la valeur postérieure à la compilation du schéma pour toutes les notations du schéma.

Parent

Obtient ou définit le parent de ce XmlSchemaObject.

(Hérité de XmlSchemaObject)
SchemaTypes

Obtient la valeur postérieure à la compilation du schéma de tous les types du schéma.

SourceUri

Obtient ou définit l'emplacement de la source pour le fichier qui a chargé le schéma.

(Hérité de XmlSchemaObject)
TargetNamespace

Obtient ou définit l'URI (Uniform Resource Identifier) de l'espace de noms cible du schéma.

UnhandledAttributes

Obtient ou définit les attributs qualifiés qui n’appartiennent pas à l’espace de noms cible du schéma.

Version

Obtient ou définit la version du schéma.

Méthodes

Compile(ValidationEventHandler)
Obsolète.
Obsolète.
Obsolète.

Compile le modèle SOM (Schema Object Model) XML en informations de schéma pour la validation. Utilisé pour vérifier les structures syntaxique et sémantique du modèle SOM construit par programmation. La vérification de la validation sémantique s’effectue pendant la compilation.

Compile(ValidationEventHandler, XmlResolver)
Obsolète.
Obsolète.
Obsolète.

Compile le modèle SOM (Schema Object Model) XML en informations de schéma pour la validation. Utilisé pour vérifier les structures syntaxique et sémantique du modèle SOM construit par programmation. La vérification de la validation sémantique s’effectue pendant la compilation.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
Read(Stream, ValidationEventHandler)

Lit un schéma XML à partir du flux fourni.

Read(TextReader, ValidationEventHandler)

Lit un schéma XML du TextReader fourni.

Read(XmlReader, ValidationEventHandler)

Lit un schéma XML du XmlReader fourni.

ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)
Write(Stream)

Écrit le schéma XML dans le flux de données fourni.

Write(Stream, XmlNamespaceManager)

Écrit le schéma XML dans le Stream fourni à l'aide du XmlNamespaceManager spécifié.

Write(TextWriter)

Écrit le schéma XML dans le TextWriter fourni.

Write(TextWriter, XmlNamespaceManager)

Écrit le schéma XML dans le TextWriter fourni.

Write(XmlWriter)

Écrit le schéma XML dans le XmlWriter fourni.

Write(XmlWriter, XmlNamespaceManager)

Écrit le schéma XML dans le XmlWriter fourni.

S’applique à

Voir aussi