XName Clase

Definición

Representa un nombre de un atributo o un elemento XML.

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
Herencia
XName
Atributos
Implementaciones

Comentarios

Los nombres XML incluyen un espacio de nombres y un nombre local. Un nombre completo es la combinación del espacio de nombres y el nombre local.

Crear un objeto XName

XName no contiene ningún constructor público. En su lugar, esta clase proporciona una conversión implícita de String que permite crear un XName. El lugar más común para usar esta conversión es al construir un elemento o atributo: el primer argumento para el XElement constructor es .XName Al pasar una cadena, se aprovecha la conversión implícita. El código siguiente crea un elemento con un nombre que no está en ningún espacio de nombres:

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

En Visual Basic, es más adecuado usar literales XML:

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

Este ejemplo produce el siguiente resultado:

<ElementName>content</ElementName>  

La asignación de una cadena a usa XName la conversión implícita de String.

En el ejemplo de Visual Basic se crea el XElement mediante literales XML. Aunque se usan literales XML, se crea un XName objeto para .XElement

Además, puede llamar al Get método para un XName objeto . Sin embargo, la manera recomendada es usar la conversión implícita de la cadena.

Crear un XName en un espacio de nombres

Al igual que con XML, un XName puede estar en un espacio de nombres o no puede estar en ningún espacio de nombres.

Para C#, el enfoque recomendado para crear un XName en un espacio de nombres es declarar el XNamespace objeto y, a continuación, usar la invalidación del operador de suma.

Para Visual Basic, el enfoque recomendado es usar literales XML y declaraciones de espacio de nombres globales para crear XML que se encuentra en un espacio de nombres.

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  

Este ejemplo produce el siguiente resultado:

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

Crear un XName en ningún espacio de nombres

Se garantiza que la Namespace propiedad de un XName objeto no es null. Si no XName está en ningún espacio de nombres, la Namespace propiedad se establecerá Noneen . El código siguiente muestra este proceso:

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  

Este ejemplo produce el siguiente resultado:

The element is in no namespace.  

Usar nombres expandidos

También puede crear a XName partir de un nombre XML expandido con el 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)  

Este ejemplo produce el siguiente resultado:

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

Tenga en cuenta que crear un XName mediante un nombre expandido es menos eficaz que crear un XNamespace objeto y usar la invalidación del operador de suma. También es menos eficaz que importar un espacio de nombres global y usar literales XML en Visual Basic.

Si crea un XName mediante un nombre expandido, LINQ to XML debe encontrar la instancia atomizada de un espacio de nombres. Este trabajo debe repetirse para cada uso de un nombre expandido. Es probable que este tiempo adicional sea insignificante al escribir consultas LINQ; sin embargo, puede ser importante al crear un árbol XML grande.

Los objetos XName se atomizan

XName Se garantiza que los objetos se atomizan; es decir, si dos XName objetos tienen exactamente el mismo espacio de nombres y exactamente el mismo nombre local, compartirán la misma instancia. Los operadores de igualdad y comparación también se proporcionan explícitamente para este fin.

Entre otras ventajas, esta característica permite una ejecución más rápida de las consultas. Al filtrar por el nombre de los elementos o atributos, las comparaciones expresadas en predicados usan la comparación de identidades, no la comparación de valores. Es mucho más rápido determinar que dos referencias hacen referencia realmente al mismo objeto que para comparar dos cadenas.

Propiedades

LocalName

Obtiene la parte local (incompleta) del nombre.

Namespace

Obtiene la parte de espacio de nombres del nombre completo.

NamespaceName

Devuelve el URI del XNamespace para este XName.

Métodos

Equals(Object)

Determina si el objeto XName especificado es igual a este objeto XName.

Get(String)

Recibe un objeto XName de un nombre expandido.

Get(String, String)

Recibe un objeto XName de un nombre local y un espacio de nombres.

GetHashCode()

Obtiene un código hash de este objeto XName.

GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.

(Heredado de Object)
ToString()

Devuelve el nombre XML expandido en el formato {namespace}localname.

Operadores

Equality(XName, XName)

Devuelve un valor que indica si dos instancias de XName son iguales.

Implicit(String to XName)

Convierte una cadena con formato como un nombre XML expandido (es decir, {namespace}localname) en un objeto XName.

Inequality(XName, XName)

Devuelve un valor que indica si dos instancias de XName no son iguales.

Implementaciones de interfaz explícitas

IEquatable<XName>.Equals(XName)

Determina si el objeto XName actual es igual al objeto XName especificado.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Rellena SerializationInfo con los datos necesarios para serializar el objeto de destino.

Se aplica a

Consulte también