XName Classe

Definizione

Rappresenta un nome di un elemento o attributo XML.Represents a name of an XML element or attribute.

public ref class XName sealed : IEquatable<System::Xml::Linq::XName ^>, System::Runtime::Serialization::ISerializable
[System.Runtime.Serialization.KnownType(typeof(System.Xml.Linq.NameSerializer))]
[System.Serializable]
public sealed class XName : IEquatable<System.Xml.Linq.XName>, System.Runtime.Serialization.ISerializable
type XName = class
    interface IEquatable<XName>
    interface ISerializable
Public NotInheritable Class XName
Implements IEquatable(Of XName), ISerializable
Ereditarietà
XName
Attributi
Implementazioni

Commenti

I nomi XML includono uno spazio dei nomi e un nome locale.XML names include a namespace and a local name. Un nome completo è la combinazione dello spazio dei nomi e del nome locale.A fully qualified name is the combination of the namespace and local name.

Creazione di un oggetto XNameCreating an XName Object

XNamenon contiene costruttori pubblici.XName does not contain any public constructors. Al contrario, questa classe fornisce una conversione implicita da String che consente di creare un oggetto. XNameInstead, this class provides an implicit conversion from String that allows you to create an XName. La posizione più comune utilizzata per la conversione è la creazione di un elemento o di un attributo: Il primo argomento per il XElement costruttore XNameè.The most common place you use this conversion is when constructing an element or attribute: The first argument to the XElement constructor is an XName. Passando una stringa, si sfrutta la conversione implicita.By passing a string, you take advantage of the implicit conversion. Il codice seguente crea un elemento con un nome che non è in uno spazio dei nomi:The following code creates an element with a name that is in no namespace:

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

In Visual Basic, è più appropriato usare i valori letterali XML:In Visual Basic, it is more appropriate to use XML literals:

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

Questo esempio produce il seguente output:This example produces the following output:

<ElementName>content</ElementName>  

L'assegnazione di una stringa a XName un oggetto usa la conversione Stringimplicita da.Assigning a string to an XName uses the implicit conversion from String.

Nell'esempio Visual Basic viene creato XElement utilizzando i valori letterali XML.The Visual Basic example creates the XElement using XML literals. Anche se vengono usati i XName XElementvalori letterali XML, viene creato un oggetto per.Even though XML literals are used, an XName object is created for the XElement.

Inoltre, è possibile chiamare il Get metodo per un XName oggetto.In addition, you can call the Get method for an XName object. Tuttavia, la modalità consigliata consiste nell'utilizzare la conversione implicita da stringa.However, the recommended way is to use the implicit conversion from string.

Creazione di un oggetto XName in uno spazio dei nomiCreating an XName in a Namespace

Come con XML, un XName può trovarsi in uno spazio dei nomi oppure non può trovarsi in nessuno spazio dei nomi.As with XML, an XName can be in a namespace, or it can be in no namespace.

Per C#, l'approccio consigliato per la creazione XName di un oggetto in uno spazio dei XNamespace nomi consiste nel dichiarare l'oggetto, quindi utilizzare l'override dell'operatore di addizione.For C#, the recommended approach for creating an XName in a namespace is to declare the XNamespace object, then use the override of the addition operator.

Per Visual Basic, l'approccio consigliato consiste nell'usare i valori letterali XML e le dichiarazioni dello spazio dei nomi globali per creare codice XML in uno spazio dei nomi.For Visual Basic, the recommended approach is to use XML literals and global namespace declarations to create XML that is in a 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  

Questo esempio produce il seguente output:This example produces the following output:

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

Creazione di un oggetto XName senza spazio dei nomiCreating an XName in no Namespace

Non Namespace è garantito che XName la proprietà di un oggetto sia null.The Namespace property of an XName object is guaranteed to not be null. Namespace NoneSe non XName è in alcun spazio dei nomi, la proprietà verrà impostata su.If the XName is in no namespace, then the Namespace property will be set to None. Nel codice seguente viene illustrato quanto segue:The following code demonstrates this:

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  

Questo esempio produce il seguente output:This example produces the following output:

The element is in no namespace.  

Uso di nomi espansiUsing Expanded Names

È anche possibile creare un XName oggetto da un nome XML espanso nel formato {namespace}localname:You can also create an XName from a expanded XML name in the form {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)  

Questo esempio produce il seguente output:This example produces the following output:

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

Tenere presente che la creazione XName di un oggetto tramite un nome espanso è meno efficiente XNamespace rispetto alla creazione di un oggetto e all'utilizzo dell'override dell'operatore di addizione.Be aware that creating an XName through an expanded name is less efficient than creating an XNamespace object and using the override of the addition operator. È anche meno efficiente rispetto all'importazione di uno spazio dei nomi globale e all'uso di valori letterali XML in Visual Basic.It is also less efficient than importing a global namespace and using XML literals in Visual Basic.

Se si crea un XName oggetto utilizzando un nome espanso, LINQ to XML necessario trovare l'istanza atomizzata di uno spazio dei nomi.If you create an XName using an expanded name, LINQ to XML must find the atomized instance of a namespace. Questa operazione deve essere ripetuta per ogni utilizzo di un nome espanso.This work must be repeated for every use of an expanded name. Questo tempo aggiuntivo è probabilmente irrilevante durante la scrittura di query LINQ; Tuttavia, potrebbe essere significativo quando si crea un albero XML di grandi dimensioni.This additional time is likely to be negligible when writing LINQ queries; however, it might be significant when creating a large XML tree.

Gli oggetti XName sono atomizzatiXName Objects are Atomized

XNamegli oggetti possono essere atomizzati. ovvero, se due XName oggetti hanno esattamente lo stesso spazio dei nomi e esattamente lo stesso nome locale, condividono la stessa istanza.XName objects are guaranteed to be atomized; that is, if two XName objects have exactly the same namespace and exactly the same local name, they will share the same instance. Gli operatori di uguaglianza e confronto vengono forniti anche in modo esplicito a questo scopo.The equality and comparison operators are also provided explicitly for this purpose.

Tra gli altri vantaggi, questa funzionalità consente una maggiore velocità di esecuzione delle query.Among other benefits, this feature allows for faster execution of queries. Quando si applica un filtro al nome di elementi o attributi, i confronti espressi nei predicati utilizzano il confronto di identità, non il confronto dei valori.When filtering on the name of elements or attributes, the comparisons expressed in predicates use identity comparison, not value comparison. È molto più veloce determinare che due riferimenti fanno effettivamente riferimento allo stesso oggetto rispetto a confrontare due stringhe.It is much faster to determine that two references actually refer to the same object than to compare two strings.

Proprietà

LocalName

Ottiene la parte locale (non qualificata) del nome.Gets the local (unqualified) part of the name.

Namespace

Ottiene la parte dello spazio dei nomi del nome completo.Gets the namespace part of the fully qualified name.

NamespaceName

Restituisce l'URI del XNamespace per questo XName.Returns the URI of the XNamespace for this XName.

Metodi

Equals(Object)

Determina se l'oggetto XName specificato è uguale a XName.Determines whether the specified XName is equal to this XName.

Get(String)

Ottiene un oggetto XName da un nome esteso.Gets an XName object from an expanded name.

Get(String, String)

Ottiene un oggetto XName da un nome locale e uno spazio dei nomi.Gets an XName object from a local name and a namespace.

GetHashCode()

Ottiene un codice hash per XName.Gets a hash code for this XName.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ToString()

Restituisce il nome XML esteso nel formato {namespace}localname.Returns the expanded XML name in the format {namespace}localname.

Operatori

Equality(XName, XName)

Restituisce un valore che indica se due istanze di XName sono uguali.Returns a value indicating whether two instances of XName are equal.

Implicit(String to XName)

Converte una stringa formattata come nome XML esteso (ovvero {namespace}localname) in un oggetto XName.Converts a string formatted as an expanded XML name (that is,{namespace}localname) to an XName object.

Inequality(XName, XName)

Restituisce un valore che indica se due istanze di XName non sono uguali.Returns a value indicating whether two instances of XName are not equal.

Implementazioni dell'interfaccia esplicita

IEquatable<XName>.Equals(XName)

Indica se l'oggetto XName corrente è uguale all'oggetto XName specificato.Indicates whether the current XName is equal to the specified XName.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Inserisce una classe SerializationInfo con i dati richiesti per serializzare l'oggetto di destinazione.Populates a SerializationInfo with the data required to serialize the target object.

Si applica a

Vedi anche