XmlSchemaUnique Classe

  • Riferimento

Definizione

Spazio dei nomi:
System.Xml.Schema
Assembly:
System.Xml.ReaderWriter.dll
Assembly:
System.Xml.dll
Assembly:
netstandard.dll

Rappresenta l'elemento unique dallo schema XML come specificato da World Wide Web Consortium (W3C). Questa classe può essere usata per identificare un vincolo univoco in un set di elementi.

public ref class XmlSchemaUnique : System::Xml::Schema::XmlSchemaIdentityConstraint
public class XmlSchemaUnique : System.Xml.Schema.XmlSchemaIdentityConstraint
type XmlSchemaUnique = class
    inherit XmlSchemaIdentityConstraint
Public Class XmlSchemaUnique
Inherits XmlSchemaIdentityConstraint
Ereditarietà
Object
XmlSchemaObject
XmlSchemaAnnotated
XmlSchemaIdentityConstraint
XmlSchemaUnique

Esempio

Nell'esempio seguente viene illustrato l'uso della XmlSchemaUnique classe .

#using <System.Xml.dll>

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

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

public:
    static void Main()
    {
        XmlSchema^ schema = gcnew XmlSchema();

        // <xs:complexType name="customerOrderType">
        XmlSchemaComplexType^ customerOrderType = gcnew XmlSchemaComplexType();
        customerOrderType->Name = "customerOrderType";

        // <xs:sequence>
        XmlSchemaSequence^ sequence1 = gcnew XmlSchemaSequence();

        // <xs:element name="item" minOccurs="0" maxOccurs="unbounded">
        XmlSchemaElement^ item = gcnew XmlSchemaElement();
        item->MinOccurs = 0;
        item->MaxOccursString = "unbounded";
        item->Name = "item";

        // <xs:complexType>
        XmlSchemaComplexType^ ct1 = gcnew XmlSchemaComplexType();

        // <xs:attribute name="itemID" type="xs:string"/>
        XmlSchemaAttribute^ itemID = gcnew XmlSchemaAttribute();
        itemID->Name = "itemID";
        itemID->SchemaTypeName = gcnew XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");

        // </xs:complexType>
        ct1->Attributes->Add(itemID);

        // </xs:element>
        item->SchemaType = ct1;

        // </xs:sequence>
        sequence1->Items->Add(item);
        customerOrderType->Particle = sequence1;

        // <xs:attribute name="CustomerID" type="xs:string"/>
        XmlSchemaAttribute^ CustomerID = gcnew XmlSchemaAttribute();
        CustomerID->Name = "CustomerID";
        CustomerID->SchemaTypeName = gcnew XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");

        customerOrderType->Attributes->Add(CustomerID);

        // </xs:complexType>
        schema->Items->Add(customerOrderType);

        // <xs:element name="ordersByCustomer">
        XmlSchemaElement^ ordersByCustomer = gcnew XmlSchemaElement();
        ordersByCustomer->Name = "ordersByCustomer";

        // <xs:complexType>
        XmlSchemaComplexType^ ct2 = gcnew XmlSchemaComplexType();

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

        // <xs:element name="customerOrders" type="customerOrderType" minOccurs="0" maxOccurs="unbounded" />
        XmlSchemaElement^ customerOrders = gcnew XmlSchemaElement();
        customerOrders->MinOccurs = 0;
        customerOrders->MaxOccursString = "unbounded";
        customerOrders->Name = "customerOrders";
        customerOrders->SchemaTypeName = gcnew XmlQualifiedName("customerOrderType", "");

        // </xs:sequence>
        sequence2->Items->Add(customerOrders);

        // </xs:complexType>
        ct2->Particle = sequence2;
        ordersByCustomer->SchemaType = ct2;

        // <xs:unique name="oneCustomerOrdersforEachCustomerID">
        XmlSchemaUnique^ element_unique = gcnew XmlSchemaUnique();
        element_unique->Name = "oneCustomerOrdersforEachCustomerID";

        // <xs:selector xpath="customerOrders"/>
        element_unique->Selector = gcnew XmlSchemaXPath();
        element_unique->Selector->XPath = "customerOrders";

        // <xs:field xpath="@customerID"/>
        XmlSchemaXPath^ field = gcnew XmlSchemaXPath();
        field->XPath = "@customerID";

        // </xs:unique>
        element_unique->Fields->Add(field);
        ordersByCustomer->Constraints->Add(element_unique);

        // </xs:element>
        schema->Items->Add(ordersByCustomer);

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

        XmlSchema^ compiledSchema = nullptr;

        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);
    }
};

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="customerOrderType">
        XmlSchemaComplexType customerOrderType = new XmlSchemaComplexType();
        customerOrderType.Name = "customerOrderType";

        // <xs:sequence>
        XmlSchemaSequence sequence1 = new XmlSchemaSequence();

        // <xs:element name="item" minOccurs="0" maxOccurs="unbounded">
        XmlSchemaElement item = new XmlSchemaElement();
        item.MinOccurs = 0;
        item.MaxOccursString = "unbounded";
        item.Name = "item";

        // <xs:complexType>
        XmlSchemaComplexType ct1 = new XmlSchemaComplexType();

        // <xs:attribute name="itemID" type="xs:string"/>
        XmlSchemaAttribute itemID = new XmlSchemaAttribute();
        itemID.Name = "itemID";
        itemID.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");

        // </xs:complexType>
        ct1.Attributes.Add(itemID);

        // </xs:element>
        item.SchemaType = ct1;

        // </xs:sequence>
        sequence1.Items.Add(item);
        customerOrderType.Particle = sequence1;

        // <xs:attribute name="CustomerID" type="xs:string"/>
        XmlSchemaAttribute CustomerID = new XmlSchemaAttribute();
        CustomerID.Name = "CustomerID";
        CustomerID.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");

        customerOrderType.Attributes.Add(CustomerID);

        // </xs:complexType>
        schema.Items.Add(customerOrderType);

        // <xs:element name="ordersByCustomer">
        XmlSchemaElement ordersByCustomer = new XmlSchemaElement();
        ordersByCustomer.Name = "ordersByCustomer";

        // <xs:complexType>
        XmlSchemaComplexType ct2 = new XmlSchemaComplexType();

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

        // <xs:element name="customerOrders" type="customerOrderType" minOccurs="0" maxOccurs="unbounded" />
        XmlSchemaElement customerOrders = new XmlSchemaElement();
        customerOrders.MinOccurs = 0;
        customerOrders.MaxOccursString = "unbounded";
        customerOrders.Name = "customerOrders";
        customerOrders.SchemaTypeName = new XmlQualifiedName("customerOrderType", "");

        // </xs:sequence>
        sequence2.Items.Add(customerOrders);

        // </xs:complexType>
        ct2.Particle = sequence2;
        ordersByCustomer.SchemaType = ct2;

        // <xs:unique name="oneCustomerOrdersforEachCustomerID">
        XmlSchemaUnique element_unique = new XmlSchemaUnique();
        element_unique.Name = "oneCustomerOrdersforEachCustomerID";

        // <xs:selector xpath="customerOrders"/>
        element_unique.Selector = new XmlSchemaXPath();
        element_unique.Selector.XPath = "customerOrders";

        // <xs:field xpath="@customerID"/>
        XmlSchemaXPath field = new XmlSchemaXPath();
        field.XPath = "@customerID";

        // </xs:unique>
        element_unique.Fields.Add(field);
        ordersByCustomer.Constraints.Add(element_unique);

        // </xs:element>
        schema.Items.Add(ordersByCustomer);

        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);
    }
}

Imports System.Xml
Imports System.Xml.Schema

Class XMLSchemaExamples
    Public Shared Sub Main()

        Dim schema As New XmlSchema()

        ' <xs:complexType name="customerOrderType">
        Dim customerOrderType As New XmlSchemaComplexType()
        customerOrderType.Name = "customerOrderType"

        ' <xs:sequence>
        Dim sequence1 As New XmlSchemaSequence()

        ' <xs:element name="item" minOccurs="0" maxOccurs="unbounded">
        Dim item As New XmlSchemaElement()
        item.MinOccurs = 0
        item.MaxOccursString = "unbounded"
        item.Name = "item"

        ' <xs:complexType>
        Dim ct1 As New XmlSchemaComplexType()

        ' <xs:attribute name="itemID" type="xs:string"/>
        Dim itemID As New XmlSchemaAttribute()
        itemID.Name = "itemID"
        itemID.SchemaTypeName = New XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema")

        ' </xs:complexType>
        ct1.Attributes.Add(itemID)

        ' </xs:element>
        item.SchemaType = ct1

        ' </xs:sequence>
        sequence1.Items.Add(item)
        customerOrderType.Particle = sequence1

        ' <xs:attribute name="CustomerID" type="xs:string"/>
        Dim CustomerID As New XmlSchemaAttribute()
        CustomerID.Name = "CustomerID"
        CustomerID.SchemaTypeName = New XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema")

        customerOrderType.Attributes.Add(CustomerID)

        ' </xs:complexType>
        schema.Items.Add(customerOrderType)

        ' <xs:element name="ordersByCustomer">
        Dim ordersByCustomer As New XmlSchemaElement()
        ordersByCustomer.Name = "ordersByCustomer"

        ' <xs:complexType>
        Dim ct2 As New XmlSchemaComplexType()

        ' <xs:sequence>
        Dim sequence2 As New XmlSchemaSequence()

        ' <xs:element name="customerOrders" type="customerOrderType" minOccurs="0" maxOccurs="unbounded" />
        Dim customerOrders As New XmlSchemaElement()
        customerOrders.MinOccurs = 0
        customerOrders.MaxOccursString = "unbounded"
        customerOrders.Name = "customerOrders"
        customerOrders.SchemaTypeName = New XmlQualifiedName("customerOrderType", "")

        ' </xs:sequence>
        sequence2.Items.Add(customerOrders)

        ' </xs:complexType>
        ct2.Particle = sequence2
        ordersByCustomer.SchemaType = ct2

        ' <xs:unique name="oneCustomerOrdersforEachCustomerID">
        Dim element_unique As New XmlSchemaUnique()
        element_unique.Name = "oneCustomerOrdersforEachCustomerID"

        ' <xs:selector xpath="customerOrders"/>
        element_unique.Selector = New XmlSchemaXPath()
        element_unique.Selector.XPath = "customerOrders"

        ' <xs:field xpath="@customerID"/>
        Dim field As New XmlSchemaXPath()
        field.XPath = "@customerID"

        ' </xs:unique>
        element_unique.Fields.Add(field)
        ordersByCustomer.Constraints.Add(element_unique)

        ' </xs:element>
        schema.Items.Add(ordersByCustomer)

        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

Per questo esempio di codice viene generato il file XML seguente.

<?xml version="1.0" encoding="IBM437"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:complexType name="customerOrderType">
        <xs:sequence>
            <xs:element name="item" minOccurs="0" maxOccurs="unbounded">
                <xs:complexType>
                    <xs:attribute name="itemID" type="xs:string"/>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
        <xs:attribute name="CustomerID" type="xs:string"/>
    </xs:complexType>

    <xs:element name="ordersByCustomer">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="customerOrders" type="customerOrderType" minOccurs="0" maxOccurs="unbounded" />
            </xs:sequence>
        </xs:complexType>
        <xs:unique name="oneCustomerOrdersforEachCustomerID">
            <xs:selector xpath="customerOrders"/>
            <xs:field xpath="@customerID"/>
        </xs:unique>
    </xs:element>
</xs:schema>

Commenti

Specifica che il valore di un attributo o di un elemento (o una combinazione di valori di attributo o di elemento) deve essere univoco all'interno dell'ambito specificato. Il nome del vincolo deve essere univoco all'interno di uno schema.

Costruttori

XmlSchemaUnique()

Inizializza una nuova istanza della classe XmlSchemaUnique.

Proprietà

Annotation

Ottiene o imposta la proprietà annotation.

(Ereditato da XmlSchemaAnnotated)
Fields

Ottiene l'insieme dei campi considerati figli per il selettore di espressioni di XML Path Language (XPath).

(Ereditato da XmlSchemaIdentityConstraint)
Id

Ottiene o imposta l'ID di stringa.

(Ereditato da XmlSchemaAnnotated)
LineNumber

Ottiene o imposta il numero di riga nel file a cui l'elemento schema fa riferimento.

(Ereditato da XmlSchemaObject)
LinePosition

Ottiene o imposta la posizione di riga nel file a cui l'elemento schema fa riferimento.

(Ereditato da XmlSchemaObject)
Name

Ottiene o imposta il nome del vincolo di identità.

(Ereditato da XmlSchemaIdentityConstraint)
Namespaces

Ottiene o imposta l'oggetto XmlSerializerNamespaces da utilizzare con questo oggetto schema.

(Ereditato da XmlSchemaObject)
Parent

Ottiene o imposta la classe padre della classe XmlSchemaObject.

(Ereditato da XmlSchemaObject)
QualifiedName

Ottiene il nome completo del vincolo di identità che contiene il valore successivo alla compilazione della proprietà QualifiedName.

(Ereditato da XmlSchemaIdentityConstraint)
Selector

Ottiene o imposta l'elemento selector dell'espressione XPath.

(Ereditato da XmlSchemaIdentityConstraint)
SourceUri

Ottiene o imposta la posizione di origine per il file che ha caricato lo schema.

(Ereditato da XmlSchemaObject)
UnhandledAttributes

Ottiene o imposta gli attributi qualificati che non appartengono allo spazio dei nomi di destinazione dello schema corrente.

(Ereditato da XmlSchemaAnnotated)

Metodi

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)

Si applica a