XName Classe

Définition

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

Object

XName

Attributs

SerializableAttribute KnownTypeAttribute

Implémente

IEquatable<XName> ISerializable

Remarques

Les noms XML incluent un espace de noms et un nom local. Un nom entièrement qualifié est la combinaison de l'espace de noms et du nom local.

Créer un objet XName

XName ne contient aucun constructeur public. Au lieu de cela, cette classe fournit une conversion implicite à partir de String, qui vous permet de créer un XName. Le lieu le plus courant où vous utilisez cette conversion est lors de 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 portant un nom qui n’est dans aucun 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>

L’affectation d’une chaîne à une XName utilise la conversion implicite à partir de String.

L’exemple Visual Basic crée le XElement en utilisant des littéraux XML. Même si des littéraux XML sont utilisés, un XName objet est créé pour le XElement.

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

Créer un XName dans un espace de noms

Comme avec XML, un XName peut se trouver dans un espace de noms, ou ne pas être dans un espace de noms.

Pour C#, l’approche recommandée pour la création d’un XName dans un espace de noms consiste à déclarer l’objet XNamespace, puis à utiliser la surcharge de l’opérateur d’addition.

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éer un XName dans aucun espace de noms

La propriété Namespace d'un objet XName est garantie de ne pas être nulle. Si XName est sans espace de noms, alors la propriété Namespace sera définie à None. Le code suivant illustre ceci :

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.

Utiliser des noms développés

Vous pouvez également créer un XName à partir d'un nom XML élargi sous la forme {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>

Notez que la création d'un XName via un nom développé est moins efficace que la création d'un objet XNamespace 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 en Visual Basic.

Si vous créez un XName à l'aide d'un nom développé, LINQ to XML doit 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 les 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 en 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.

Voir aussi

• Vue d’ensemble de LINQ to XML