XName Classe

Definizione

public ref class XName sealed : IEquatable<System::Xml::Linq::XName ^>

public ref class XName sealed : IEquatable<System::Xml::Linq::XName ^>, System::Runtime::Serialization::ISerializable

public sealed class XName : IEquatable<System.Xml.Linq.XName>

public sealed class XName : IEquatable<System.Xml.Linq.XName>, System.Runtime.Serialization.ISerializable

[System.Serializable]
public sealed class XName : IEquatable<System.Xml.Linq.XName>, System.Runtime.Serialization.ISerializable

[System.Serializable]
[System.Runtime.Serialization.KnownType(typeof(System.Xml.Linq.NameSerializer))]
public sealed class XName : IEquatable<System.Xml.Linq.XName>, System.Runtime.Serialization.ISerializable

type XName = class
    interface IEquatable<XName>

type XName = class
    interface IEquatable<XName>
    interface ISerializable

[<System.Serializable>]
type XName = class
    interface IEquatable<XName>
    interface ISerializable

[<System.Serializable>]
[<System.Runtime.Serialization.KnownType(typeof(System.Xml.Linq.NameSerializer))>]
type XName = class
    interface IEquatable<XName>
    interface ISerializable

Public NotInheritable Class XName
Implements IEquatable(Of XName)

Public NotInheritable Class XName
Implements IEquatable(Of XName), ISerializable

Ereditarietà

Object

XName

Attributi

SerializableAttribute KnownTypeAttribute

Implementazioni

IEquatable<XName> ISerializable

Commenti

I nomi XML includono uno spazio dei nomi e un nome locale. Un nome completamente qualificato è la combinazione del namespace 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 del XElement costruttore è un XName oggetto. Passando una stringa, si sfrutta la conversione implicita. Il codice seguente crea un elemento con un nome che non appartiene a nessuno 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)

In questo esempio viene generato 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 un XName nello spazio dei nomi consiste nel dichiarare l'oggetto XNamespace e poi utilizzare l'override dell'operatore di addizione.

Per Visual Basic, l'approccio consigliato consiste nell'usare letterali XML e dichiarazioni di namespace globali per creare XML in un namespace.

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

In questo esempio viene generato 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 XName non è in nessuno spazio dei nomi, 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

In questo esempio viene generato 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)

In questo esempio viene generato 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. Gli operatori di uguaglianza e confronto vengono forniti in modo esplicito per questo scopo.

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.

Vedi anche

• Panoramica di LINQ to XML