XmlSchema Classe

Référence

Définition

Espace de noms:: System.Xml.Schema

Assembly:: System.Xml.ReaderWriter.dll

Assembly:: System.Xml.dll

Assembly:: netstandard.dll

Source:: XmlSchema.cs

Source:: XmlSchema.cs

Source:: XmlSchema.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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: Object
XmlSchema

Héritage: Object

XmlSchemaObject
XmlSchema

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 à