Classe System.Xml.Linq.XName

Questo articolo fornisce osservazioni supplementari alla documentazione di riferimento per questa API.

I nomi XML includono uno spazio dei nomi e un nome locale. Un nome completo è la combinazione dello spazio dei nomi e del nome locale.

Creare un oggetto XName

XName non contiene costruttori pubblici. Questa classe fornisce invece una conversione implicita da String che consente di creare un oggetto XName. La posizione più comune in cui si usa questa conversione è quando si costruisce un elemento o un attributo: il primo argomento per il XElement costruttore è un XNameoggetto . Passando una stringa, si sfrutta la conversione implicita. Il codice seguente crea un elemento con un nome senza spazio dei nomi:

XElement root = new XElement("ElementName", "content");
Console.WriteLine(root);

In Visual Basic è più appropriato usare valori letterali XML:

Dim root As XElement = <ElementName>content</ElementName>
Console.WriteLine(root)

Nell'esempio viene prodotto l'output seguente:

<ElementName>content</ElementName>

L'assegnazione di una stringa a un XName usa la conversione implicita da String.

Nell'esempio di Visual Basic viene creato l'oggetto XElement utilizzando valori letterali XML. Anche se vengono utilizzati valori letterali XML, viene creato un XName oggetto per .XElement

Inoltre, è possibile chiamare il Get metodo per un XName oggetto . Tuttavia, il modo consigliato consiste nell'usare la conversione implicita da stringa.

Creare un XName in uno spazio dei nomi

Come per XML, un XName può trovarsi in uno spazio dei nomi oppure non può trovarsi in alcuno spazio dei nomi.

Per C#, l'approccio consigliato per la creazione di in XName uno spazio dei nomi consiste nel dichiarare l'oggetto XNamespace , quindi usare l'override dell'operatore di addizione.

Per Visual Basic, l'approccio consigliato consiste nell'usare valori letterali XML e dichiarazioni di spazi dei nomi globali per creare codice XML in uno spazio dei nomi.

XNamespace aw = "http://www.adventure-works.com";
XElement root = new XElement(aw + "ElementName", "content");
Console.WriteLine(root);

Imports <xmlns="http://www.adventure-works.com">

Module Module1
    Sub Main()
        Dim root As XElement = <ElementName>content</ElementName>
        Console.WriteLine(root)
    End Sub
End Module

Nell'esempio viene prodotto l'output seguente:

<ElementName xmlns="http://www.adventure-works.com">content</ElementName>

Creare un XName senza spazio dei nomi

La Namespace proprietà di un XName oggetto non deve essere Null. Se non XName è presente alcuno spazio dei nomi, la Namespace proprietà verrà impostata su None. Il codice seguente illustra quanto segue:

XElement root = new XElement("ElementName", "content");
if (root.Name.Namespace == XNamespace.None)
    Console.WriteLine("The element is in no namespace.");
else
    Console.WriteLine("The element is in a namespace.");

Dim root As XElement = <ElementName>content</ElementName>
If (root.Name.Namespace Is XNamespace.None) Then
    Console.WriteLine("The element is in no namespace.")
Else
    Console.WriteLine("The element is in a namespace.")
End If

Nell'esempio viene prodotto l'output seguente:

The element is in no namespace.

Usare nomi espansi

È anche possibile creare un oggetto XName da un nome XML espanso nel formato {namespace}localname:

XElement root = new XElement("{http://www.adventure-works.com}ElementName", "content");
Console.WriteLine(root);

Dim root As XElement = New XElement("{http://www.adventure-works.com}ElementName", "content")
Console.WriteLine(root)

Nell'esempio viene prodotto l'output seguente:

<ElementName xmlns="http://www.adventure-works.com">content</ElementName>

Tenere presente che la creazione di un oggetto XName tramite un nome espanso è meno efficiente rispetto alla creazione di un XNamespace oggetto e all'uso dell'override dell'operatore di addizione. È anche meno efficiente dell'importazione di uno spazio dei nomi globale e dell'uso di valori letterali XML in Visual Basic.

Se si crea un XName oggetto utilizzando un nome espanso, LINQ to XML deve trovare l'istanza atomizzata di uno spazio dei nomi. Questo lavoro deve essere ripetuto per ogni utilizzo di un nome espanso. È probabile che questo tempo aggiuntivo sia trascurabile durante la scrittura di query LINQ; Tuttavia, potrebbe essere significativo quando si crea un albero XML di grandi dimensioni.

Gli oggetti XName vengono atomizzati

XName gli oggetti sono sicuramente atomizzati; ovvero, se due XName oggetti hanno esattamente lo stesso spazio dei nomi e esattamente lo stesso nome locale, condividono la stessa istanza. A questo scopo vengono forniti anche gli operatori di uguaglianza e confronto in modo esplicito.

Tra gli altri vantaggi, questa funzionalità consente un'esecuzione più rapida delle query. Quando si filtra il nome di elementi o attributi, i confronti espressi nei predicati usano il confronto tra identità e non il confronto dei valori. È molto più veloce determinare che due riferimenti fanno effettivamente riferimento allo stesso oggetto rispetto a confrontare due stringhe.