XName XName XName XName Class

Definición

Representa un nombre de un elemento o atributo 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
Herencia
XNameXNameXNameXName
Atributos
Implementaciones

Comentarios

Los nombres XML incluyen un espacio de nombres y un nombre local.XML names include a namespace and a local name. Un nombre completo es la combinación del espacio de nombres y el nombre local.A fully qualified name is the combination of the namespace and local name.

Creación de un objeto XNameCreating an XName Object

XName no tiene ningún constructor público.XName does not contain any public constructors. En su lugar, esta clase proporciona una conversión implícita de String que le permite crear un XName.Instead, this class provides an implicit conversion from String that allows you to create an XName. El lugar más habitual usar esta conversión es al construir un elemento o atributo: El primer argumento para el XElement constructor es un 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. Al pasar una cadena, aprovechar la conversión implícita.By passing a string, you take advantage of the implicit conversion. El código siguiente crea un elemento con un nombre que se encuentra en ningún espacio de nombres:The following code creates an element with a name that is in no namespace:

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

En Visual Basic, es más adecuado usar literales XML:In Visual Basic, it is more appropriate to use XML literals:

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

Este ejemplo produce el siguiente resultado:This example produces the following output:

<ElementName>content</ElementName>  

Asignando una cadena a un XName utiliza la conversión implícita de String.Assigning a string to an XName uses the implicit conversion from String.

El ejemplo de Visual Basic crea el XElement mediante literales XML.The Visual Basic example creates the XElement using XML literals. Aunque se utilizan literales XML, un XName se crea el objeto para el XElement.Even though XML literals are used, an XName object is created for the XElement.

Además, puede llamar a la Get método para un XName objeto.In addition, you can call the Get method for an XName object. Sin embargo, la manera recomendada es usar la conversión implícita de cadena.However, the recommended way is to use the implicit conversion from string.

Creación de un XName en un NamespaceCreating an XName in a Namespace

Al igual que con XML, un XName puede estar en un espacio de nombres, o puede estar en ningún espacio de nombres.As with XML, an XName can be in a namespace, or it can be in no namespace.

Para C#, el enfoque recomendado para crear un XName en un espacio de nombres es declarar la XNamespace de objeto y, después, use la invalidación del operador de suma.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.

Para Visual Basic, el enfoque recomendado es utilizar literales XML y declaraciones de espacio de nombres global para crear XML que se encuentra en un espacio de nombres.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  

Este ejemplo produce el siguiente resultado:This example produces the following output:

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

Creación de un XName en ningún NamespaceCreating an XName in no Namespace

El Namespace propiedad de un XName objeto garantiza que no sea nulo.The Namespace property of an XName object is guaranteed to not be null. Si el XName en ningún espacio de nombres, el Namespace propiedad se establecerá en None.If the XName is in no namespace, then the Namespace property will be set to None. El siguiente código muestra esto: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  

Este ejemplo produce el siguiente resultado:This example produces the following output:

The element is in no namespace.  

Usar nombres expandidosUsing Expanded Names

También puede crear un XName de un nombre XML expandido en el formulario {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)  

Este ejemplo produce el siguiente resultado:This example produces the following output:

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

Tenga en cuenta que la creación un XName a través de un nombre expandido es menos eficaz que crear un XNamespace objeto y el uso de la invalidación del operador de suma.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. También es menos eficaz que importar un espacio de nombres global y utilizar literales XML en Visual Basic.It is also less efficient than importing a global namespace and using XML literals in Visual Basic.

Si creas un XName con un nombre expandido, LINQ to XML debe buscar la instancia de un espacio de nombres atomizada.If you create an XName using an expanded name, LINQ to XML must find the atomized instance of a namespace. Este trabajo debe repetirse para cada uso de un nombre expandido.This work must be repeated for every use of an expanded name. Este tiempo adicional es probable que sea insignificante al escribir consultas LINQ; Sin embargo, podría ser importante al crear un árbol XML grande.This additional time is likely to be negligible when writing LINQ queries; however, it might be significant when creating a large XML tree.

Objetos XName se subdividenXName Objects are Atomized

XName se garantiza que los objetos se subdividen; es decir, si dos XName objetos tienen exactamente el mismo espacio de nombres y exactamente el mismo nombre local, compartirán la misma instancia.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. Los operadores de comparación e igualdad también se proporcionan explícitamente para este propósito.The equality and comparison operators are also provided explicitly for this purpose.

Entre otras ventajas, esta característica permite una ejecución más rápida de consultas.Among other benefits, this feature allows for faster execution of queries. Al filtrar por el nombre de elementos o atributos, las comparaciones expresadas en predicados usan comparación de identidades, no la comparación de valores.When filtering on the name of elements or attributes, the comparisons expressed in predicates use identity comparison, not value comparison. Es mucho más rápido para determinar que dos referencias hacen referencia realmente al mismo objeto de comparar dos cadenas.It is much faster to determine that two references actually refer to the same object than to compare two strings.

Propiedades

LocalName LocalName LocalName LocalName

Obtiene la parte local (incompleta) del nombre.Gets the local (unqualified) part of the name.

Namespace Namespace Namespace Namespace

Obtiene la parte de espacio de nombres del nombre completo.Gets the namespace part of the fully qualified name.

NamespaceName NamespaceName NamespaceName NamespaceName

Devuelve el URI del XNamespace para este XName.Returns the URI of the XNamespace for this XName.

Métodos

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina si el objeto XName especificado es igual a este objeto XName.Determines whether the specified XName is equal to this XName.

Get(String) Get(String) Get(String) Get(String)

Recibe un objeto XName de un nombre expandido.Gets an XName object from an expanded name.

Get(String, String) Get(String, String) Get(String, String) Get(String, String)

Recibe un objeto XName de un nombre local y un espacio de nombres.Gets an XName object from a local name and a namespace.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Obtiene el código hash de XName.Gets a hash code for this XName.

GetType() GetType() GetType() GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Devuelve el nombre XML expandido en el formato {namespace}localname.Returns the expanded XML name in the format {namespace}localname.

Operadores

Equality(XName, XName) Equality(XName, XName) Equality(XName, XName) Equality(XName, XName)

Devuelve un valor que indica si dos instancias de XName son iguales.Returns a value indicating whether two instances of XName are equal.

Implicit(String to XName) Implicit(String to XName) Implicit(String to XName) Implicit(String to XName)

Convierte una cadena con formato como un nombre XML expandido (es decir, {namespace}localname) en un objeto XName.Converts a string formatted as an expanded XML name (that is,{namespace}localname) to an XName object.

Inequality(XName, XName) Inequality(XName, XName) Inequality(XName, XName) Inequality(XName, XName)

Devuelve un valor que indica si dos instancias de XName no son iguales.Returns a value indicating whether two instances of XName are not equal.

Implementaciones de interfaz explícitas

IEquatable<XName>.Equals(XName) IEquatable<XName>.Equals(XName) IEquatable<XName>.Equals(XName) IEquatable<XName>.Equals(XName)

Indica si el XName actual es igual al XName especificado.Indicates whether the current XName is equal to the specified XName.

ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Rellena SerializationInfo con los datos necesarios para serializar el objeto de destino.Populates a SerializationInfo with the data required to serialize the target object.

Se aplica a

Consulte también: