XName Clase

Definición

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

Object

XName

Atributos

SerializableAttribute KnownTypeAttribute

Implementaciones

IEquatable<XName> ISerializable

Comentarios

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

Creación de 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 en el que se usa esta conversión es al construir un elemento o atributo: el primer argumento para el XElement constructor es .XName Al pasar una cadena de caracteres, 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 un XName utiliza la conversión implícita de String.

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

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

Creación de 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 pertenece a 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>

Creación de un XName sin espacio de nombres

Se garantiza que la Namespace propiedad de un XName objeto no sea NULL. Si XName no está en ningún espacio de nombres, la propiedad Namespace se establecerá en None. El código siguiente muestra esto:

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

Puede crear XName a 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 a través de un nombre expandido es menos eficiente que crear un objeto XNamespace y usar la sobrecarga 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 con 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 propósito.

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.

Consulte también

• Información general sobre LINQ to XML