XName Classe

Définition

Représente un nom d'un élément ou attribut 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
Héritage
XName
Attributs
Implémente

Remarques

Les noms XML incluent un espace de noms et un nom local. Un nom complet est la combinaison de l’espace de noms et du nom local.

Création d’un objet XName

XName ne contient aucun constructeur public. Au lieu de cela, cette classe fournit une conversion implicite à partir de String laquelle vous pouvez créer un XName. Le lieu le plus courant que vous utilisez cette conversion est la construction d’un élément ou d’un attribut : le premier argument du XElement constructeur est un XName. En passant une chaîne, vous tirez parti de la conversion implicite. Le code suivant crée un élément avec un nom qui n’est pas d’espace de noms :

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

Dans Visual Basic, il est plus approprié d’utiliser des littéraux XML :

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

Cet exemple produit la sortie suivante :

<ElementName>content</ElementName>  

Affectation d’une chaîne à une XName utilisation de la conversion implicite à partir de String.

L’exemple Visual Basic crée l’utilisation de XElement littéraux XML. Même si les littéraux XML sont utilisés, un XName objet est créé pour le XElement.

En outre, vous pouvez appeler la Get méthode pour un XName objet. Toutefois, la méthode recommandée consiste à utiliser la conversion implicite à partir de la chaîne.

Création d’un XName dans un espace de noms

Comme avec XML, un XName espace de noms peut être dans un espace de noms, ou il ne peut pas y avoir d’espace de noms.

Pour C#, l’approche recommandée pour créer un XName espace de noms consiste à déclarer l’objet XNamespace , puis à utiliser le remplacement de l’opérateur d’ajout.

Pour Visual Basic, l’approche recommandée consiste à utiliser des littéraux XML et des déclarations d’espace de noms globaux pour créer du code XML qui se trouve dans un espace de noms.

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  

Cet exemple produit la sortie suivante :

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

Création d’un XName dans aucun espace de noms

La Namespace propriété d’un XName objet est garantie de ne pas avoir la valeur Null. Si l’espace XName de noms n’est pas défini, la Namespace propriété est définie Nonesur . Le code suivant illustre cela :

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  

Cet exemple produit la sortie suivante :

The element is in no namespace.  

Utilisation de noms développés

Vous pouvez également créer un XName nom XML développé dans le formulaire {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)  

Cet exemple produit la sortie suivante :

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

N’oubliez pas que la création d’un XName nom développé est moins efficace que la création d’un XNamespace objet et l’utilisation du remplacement de l’opérateur d’ajout. Il est également moins efficace que d’importer un espace de noms global et d’utiliser des littéraux XML dans Visual Basic.

Si vous créez un XName nom développé à l’aide d’un nom développé, LINQ to XML devez trouver l’instance atomisée d’un espace de noms. Ce travail doit être répété pour chaque utilisation d’un nom développé. Ce temps supplémentaire est susceptible d’être négligeable lors de l’écriture de requêtes LINQ ; Toutefois, il peut être important lors de la création d’une arborescence XML volumineuse.

Les objets XName sont atomisés

XName les objets sont garantis d’être atomisés ; autrement dit, si deux XName objets ont exactement le même espace de noms et exactement le même nom local, ils partageront la même instance. Les opérateurs d’égalité et de comparaison sont également fournis explicitement à cet effet.

Parmi d’autres avantages, cette fonctionnalité permet une exécution plus rapide des requêtes. Lors du filtrage sur le nom des éléments ou des attributs, les comparaisons exprimées dans les prédicats utilisent la comparaison d’identité, et non la comparaison des valeurs. Il est beaucoup plus rapide de déterminer que deux références font réellement référence au même objet que pour comparer deux chaînes.

Propriétés

LocalName

Obtient la partie locale (non qualifiée) du nom.

Namespace

Obtient la partie de l'espace de noms du nom qualifié complet.

NamespaceName

Retourne l'URI du XNamespace pour ce XName.

Méthodes

Equals(Object)

Détermine si le XName spécifié est égal à ce XName.

Get(String)

Obtient un objet XName à partir d'un nom développé.

Get(String, String)

Obtient un objet XName à partir d'un nom local et d'un espace de noms.

GetHashCode()

Obtient un code de hachage pour ce XName.

GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
ToString()

Retourne le nom XML développé au format {namespace}localname.

Opérateurs

Equality(XName, XName)

Retourne une valeur indiquant si deux instances de XName sont égales.

Implicit(String to XName)

Convertit une chaîne mise en forme en tant que nom XML développé (c’est-à-dire, {namespace}localname) en objet XName.

Inequality(XName, XName)

Retourne une valeur indiquant si deux instances de XName ne sont pas égales.

Implémentations d’interfaces explicites

IEquatable<XName>.Equals(XName)

Indique si le XName actif est égal au XName spécifié.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Remplit un SerializationInfo avec les données nécessaires pour sérialiser l'objet cible.

S’applique à

Voir aussi