XmlSchemaComplexContent 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:
XmlSchemaComplexContent.cs
Source:
XmlSchemaComplexContent.cs
Source:
XmlSchemaComplexContent.cs

Représente l'élément complexContent issu d'un schéma XML comme spécifié par le W3C (World Wide Web Consortium). Cette classe représente le modèle de contenu complexe des types complexes. Elle contient des extensions ou des restrictions portant sur un type complexe qui contient uniquement des éléments ou un contenu mixte.

public ref class XmlSchemaComplexContent : System::Xml::Schema::XmlSchemaContentModel
public class XmlSchemaComplexContent : System.Xml.Schema.XmlSchemaContentModel
type XmlSchemaComplexContent = class
    inherit XmlSchemaContentModel
Public Class XmlSchemaComplexContent
Inherits XmlSchemaContentModel
Héritage
Object
XmlSchemaObject
XmlSchemaAnnotated
XmlSchemaContentModel
XmlSchemaComplexContent

Exemples

L’exemple suivant crée un complexContent élément .

#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:complexType name="address">
        XmlSchemaComplexType^ address = gcnew XmlSchemaComplexType();
        schema->Items->Add(address);
        address->Name = "address";

        // <xs:sequence>
        XmlSchemaSequence^ sequence = gcnew XmlSchemaSequence();
        address->Particle = sequence;

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

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

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

        // <xs:complexType name="USAddress">
        XmlSchemaComplexType^ USAddress = gcnew XmlSchemaComplexType();
        schema->Items->Add(USAddress);
        USAddress->Name = "USAddress";

        // <xs:complexContent>
        XmlSchemaComplexContent^ complexContent = gcnew XmlSchemaComplexContent();
        USAddress->ContentModel = complexContent;

        // <xs:extension base="address">
        XmlSchemaComplexContentExtension^ extensionAddress = gcnew XmlSchemaComplexContentExtension();
        complexContent->Content = extensionAddress;
        extensionAddress->BaseTypeName = gcnew XmlQualifiedName("address");

        // <xs:sequence>
        XmlSchemaSequence^ sequence2 = gcnew XmlSchemaSequence();
        extensionAddress->Particle = sequence2;

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


        // <xs:element name="zipcode" type="xs:positiveInteger"/>
        XmlSchemaElement^ elementZipcode = gcnew XmlSchemaElement();
        sequence2->Items->Add(elementZipcode);
        elementZipcode->Name = "zipcode";
        elementZipcode->SchemaTypeName = gcnew XmlQualifiedName("positiveInteger", "http://www.w3.org/2001/XMLSchema");

        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:complexType name="address">
        XmlSchemaComplexType address = new XmlSchemaComplexType();
        schema.Items.Add(address);
        address.Name = "address";

        // <xs:sequence>
        XmlSchemaSequence sequence = new XmlSchemaSequence();
        address.Particle = sequence;

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

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

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

        // <xs:complexType name="USAddress">
        XmlSchemaComplexType USAddress = new XmlSchemaComplexType();
        schema.Items.Add(USAddress);
        USAddress.Name = "USAddress";

        // <xs:complexContent>
        XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent();
        USAddress.ContentModel = complexContent;

        // <xs:extension base="address">
        XmlSchemaComplexContentExtension extensionAddress = new XmlSchemaComplexContentExtension();
        complexContent.Content = extensionAddress;
        extensionAddress.BaseTypeName = new XmlQualifiedName("address");

        // <xs:sequence>
        XmlSchemaSequence sequence2 = new XmlSchemaSequence();
        extensionAddress.Particle = sequence2;

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

        // <xs:element name="zipcode" type="xs:positiveInteger"/>
        XmlSchemaElement elementZipcode = new XmlSchemaElement();
        sequence2.Items.Add(elementZipcode);
        elementZipcode.Name = "zipcode";
        elementZipcode.SchemaTypeName = new XmlQualifiedName("positiveInteger", "http://www.w3.org/2001/XMLSchema");

        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 Strict On
Option Explicit On

Imports System.Xml
Imports System.Xml.Schema

Class XMLSchemaExamples

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

        ' <xs:complexType name="address">
        Dim address As New XmlSchemaComplexType()
        schema.Items.Add(address)
        address.Name = "address"

        ' <xs:sequence>
        Dim sequence As New XmlSchemaSequence()
        address.Particle = sequence

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

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

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

        ' <xs:complexType name="USAddress">
        Dim USAddress As New XmlSchemaComplexType()
        schema.Items.Add(USAddress)
        USAddress.Name = "USAddress"

        ' <xs:complexContent>
        Dim complexContent As New XmlSchemaComplexContent()
        USAddress.ContentModel = complexContent

        ' <xs:extension base="address">
        Dim extensionAddress As New XmlSchemaComplexContentExtension()
        complexContent.Content = extensionAddress
        extensionAddress.BaseTypeName = New XmlQualifiedName("address")

        ' <xs:sequence>
        Dim sequence2 As New XmlSchemaSequence()
        extensionAddress.Particle = sequence2

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


        ' <xs:element name="zipcode" type="xs:positiveInteger"/>
        Dim elementZipcode As New XmlSchemaElement()
        sequence2.Items.Add(elementZipcode)
        elementZipcode.Name = "zipcode"
        elementZipcode.SchemaTypeName = New XmlQualifiedName("positiveInteger", "http://www.w3.org/2001/XMLSchema")

        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:complexType name="address">
        <xs:sequence>
            <xs:element name="name"   type="xs:string"/>
            <xs:element name="street" type="xs:string"/>
            <xs:element name="city"   type="xs:string"/>
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="USAddress">
        <xs:complexContent mixed="false">
            <xs:extension base="address">
                <xs:sequence>
                    <xs:element name="state" type="xs:string"/>
                    <xs:element name="zipcode" type="xs:positiveInteger"/>
                </xs:sequence>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
</xs:schema>

Constructeurs

XmlSchemaComplexContent()

Initialise une nouvelle instance de la classe XmlSchemaComplexContent.

Propriétés

Annotation

Obtient ou définit la propriété annotation.

(Hérité de XmlSchemaAnnotated)
Content

Obtient ou définit le contenu.
Id

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

(Hérité de XmlSchemaAnnotated)
IsMixed

Obtient ou définit les informations qui déterminent si le type possède un modèle de contenu mixte.
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)
Parent

Obtient ou définit le parent de ce XmlSchemaObject.

(Hérité de XmlSchemaObject)
SourceUri

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

(Hérité de XmlSchemaObject)
UnhandledAttributes

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

(Hérité de XmlSchemaAnnotated)

Méthodes

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)
ToString()

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

(Hérité de Object)

S’applique à