XName Clase

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
XName
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

XNameno contiene ningún constructor público.XName does not contain any public constructors. En su lugar, esta clase proporciona una conversión implícita String de que permite crear un. XNameInstead, this class provides an implicit conversion from String that allows you to create an 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 XNamees.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, se aprovecha la conversión implícita.By passing a string, you take advantage of the implicit conversion. En el código siguiente se crea un elemento con un nombre que no está 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>  

Al asignar una cadena a un XName se usa la conversión implícita de. StringAssigning a string to an XName uses the implicit conversion from String.

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

Además, puede llamar al 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 la cadena.However, the recommended way is to use the implicit conversion from string.

Creación de un XName en un espacio de nombresCreating an XName in a Namespace

Como con XML, XName puede estar en un espacio de nombres o puede no 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 XNamespace el objeto y, a continuación, usar 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.

Por Visual Basic, el enfoque recomendado es usar literales XML y declaraciones de espacios de nombres globales para crear XML que esté 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>  

Crear un XName sin espacio de nombresCreating an XName in no Namespace

Se Namespace garantiza que la XName propiedad de un objeto no es NULL.The Namespace property of an XName object is guaranteed to not be null. Namespace NoneSi no XName está en ningún espacio de nombres, la propiedad se establecerá en.If the XName is in no namespace, then the Namespace property will be set to None. En el código siguiente se muestra lo siguiente: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 XName a partir de un nombre XML expandido con el {namespace}localnameformato: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 XName creación de un objeto mediante un nombre expandido es XNamespace menos eficaz que la creación de un 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 la importación de un espacio de nombres global y el uso de literales XML en Visual Basic.It is also less efficient than importing a global namespace and using XML literals in Visual Basic.

Si crea XName con un nombre expandido, LINQ to XML debe encontrar la instancia subdividida de un espacio de nombres.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. Es probable que este tiempo adicional sea insignificante al escribir consultas LINQ; sin embargo, podría ser importante al crear un árbol XML de gran tamaño.This additional time is likely to be negligible when writing LINQ queries; however, it might be significant when creating a large XML tree.

Los objetos XName se subdividenXName Objects are Atomized

XNamese garantiza que los objetos se van a atomizar; 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 y igualdad también se proporcionan explícitamente para este fin.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 las 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 los predicados usan la 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 determinar que dos referencias realmente hacen referencia al mismo objeto que 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

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

Namespace

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

NamespaceName

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

Métodos

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)

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

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()

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

GetType()

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

(Heredado de Object)
MemberwiseClone()

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

(Heredado de Object)
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)

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)

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)

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)

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)

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: