XmlSchemaUnique Classe

Referência

Definição

Namespace:: System.Xml.Schema

Assembly:: System.Xml.ReaderWriter.dll

Assembly:: System.Xml.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Representa o elemento unique do esquema XML, conforme especificado pelo W3C (World Wide Web Consortium). Essa classe pode ser usada para identificar uma restrição exclusiva entre um conjunto de elementos.

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

Herança: Object

XmlSchemaObject

XmlSchemaAnnotated

XmlSchemaIdentityConstraint
XmlSchemaUnique

Exemplos

O exemplo a seguir mostra o uso da 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

O arquivo XML a seguir é gerado para este exemplo de código.

<?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>

Comentários

Especifica que um valor de atributo ou elemento (ou uma combinação de valores de atributo ou elemento) deve ser exclusivo dentro do escopo especificado. O nome da restrição deve ser exclusivo dentro de um esquema.

Construtores

XmlSchemaUnique()

Inicializa uma nova instância da classe XmlSchemaUnique.

Propriedades

Annotation	Obtém ou define a propriedade `annotation`. (Herdado de XmlSchemaAnnotated)
Fields	Obtém a coleção de campos que se aplicam como filhos do seletor de expressão XPath (XML Path Language). (Herdado de XmlSchemaIdentityConstraint)
Id	Obtém ou define a ID de cadeia de caracteres. (Herdado de XmlSchemaAnnotated)
LineNumber	Obtém ou define o número de linha no arquivo ao qual o elemento `schema` se refere. (Herdado de XmlSchemaObject)
LinePosition	Obtém ou define a posição da linha no arquivo ao qual o elemento `schema` se refere. (Herdado de XmlSchemaObject)
Name	Obtém ou define o nome da restrição de identidade. (Herdado de XmlSchemaIdentityConstraint)
Namespaces	Obtém ou define o XmlSerializerNamespaces a ser usado com esse objeto de esquema. (Herdado de XmlSchemaObject)
Parent	Obtém ou define o pai deste XmlSchemaObject. (Herdado de XmlSchemaObject)
QualifiedName	Obtém o nome qualificado da restrição de identidade, que contém o valor de pós-compilação da propriedade `QualifiedName`. (Herdado de XmlSchemaIdentityConstraint)
Selector	Obtém ou define o elemento `selector` da expressão XPath. (Herdado de XmlSchemaIdentityConstraint)
SourceUri	Obtém ou define o local de origem para o arquivo que carregou o esquema. (Herdado de XmlSchemaObject)
UnhandledAttributes	Obtém ou define os atributos qualificados que não pertencem ao namespace de destino do esquema atual. (Herdado de XmlSchemaAnnotated)

Métodos

Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)

Aplica-se a

Partilhar via