Classe System.Xml.Linq.XNamespace

Cet article fournit des remarques supplémentaires à la documentation de référence de cette API.

Cette classe représente la construction XML des espaces de noms.

Chaque XName contient un XNamespace. Même si un élément n’est pas dans un espace de noms, l’élément XName contient toujours un espace de noms. XNamespace.None La propriété XName.Namespace est assurée de ne pas être null.

Créer un objet XNamespace

La façon la plus courante de créer un XNamespace objet consiste simplement à lui attribuer une chaîne. Vous pouvez ensuite combiner l’espace de noms avec un nom local à l’aide du remplacement de l’opérateur d’addition. L’exemple suivant montre cet idiome :

XNamespace aw = "http://www.adventure-works.com";
XElement root = new XElement(aw + "Root", "Content");
Console.WriteLine(root);

Dim aw As XNamespace = "http://www.adventure-works.com"
Dim root As XElement = New XElement(aw + "Root", "Content")
Console.WriteLine(root)

Toutefois, dans Visual Basic, vous devez généralement déclarer un espace de noms par défaut global, comme suit :

Imports <xmlns='http://www.adventure-works.com'>

Module Module1
    Sub Main()
        Dim root As XElement = _
            <Root>Content</Root>
        Console.WriteLine(root)
    End Sub
End Module

Cet exemple génère la sortie suivante :

<Root xmlns="http://www.adventure-works.com">Content</Root>

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

Découvrez comment créer un document avec des espaces de noms en C# (LINQ to XML) pour plus d’informations et d’exemples.

Pour plus d’informations sur l’utilisation d’espaces de noms dans Visual Basic, consultez Utiliser des espaces de noms XML .

Contrôler les préfixes d’espaces de noms

Si vous créez un attribut qui déclare un espace de noms, le préfixe spécifié dans l’attribut est conservé dans le code XML sérialisé. Pour créer un attribut qui déclare un espace de noms avec un préfixe, vous créez un attribut où l’espace de noms du nom de l’attribut est Xmlns, et le nom de l’attribut est le préfixe d’espace de noms. La valeur de l’attribut est l’URI de l’espace de noms. L’exemple suivant montre cet idiome :

XNamespace aw = "http://www.adventure-works.com";
XElement root = new XElement(aw + "Root",
    new XAttribute(XNamespace.Xmlns + "aw", "http://www.adventure-works.com"),
    "Content");
Console.WriteLine(root);

Dim aw As XNamespace = "http://www.adventure-works.com"
Dim root As XElement = New XElement(aw + "Root", _
    New XAttribute(XNamespace.Xmlns + "aw", "http://www.adventure-works.com"), _
    "Content")
Console.WriteLine(root)

Dans Visual Basic, au lieu de créer un nœud d’espace de noms pour contrôler les préfixes d’espace de noms, vous utilisez généralement une déclaration d’espace de noms globale :

Imports <xmlns:aw='http://www.adventure-works.com'>

Module Module1
    Sub Main()
        Dim root As XElement = _
            <aw:Root>Content</aw:Root>
        Console.WriteLine(root)
    End Sub
End Module

Cet exemple génère la sortie suivante :

<aw:Root xmlns:aw="http://www.adventure-works.com">Content</aw:Root>

Pour plus d’informations, consultez Comment contrôler les préfixes d’espace de noms.

Créer un espace de noms par défaut

Lors de la construction d’un attribut qui sera un espace de noms, si le nom de l’attribut a la valeur spéciale « xmlns », lorsque l’arborescence XML est sérialisée, l’espace de noms est déclaré comme espace de noms par défaut. L’attribut spécial portant le nom « xmlns » lui-même n’est pas dans un espace de noms. La valeur de l’attribut est l’URI de l’espace de noms.

L’exemple suivant crée une arborescence XML qui contient un attribut déclaré de telle sorte que l’espace de noms devienne l’espace de noms par défaut :

XNamespace aw = "http://www.adventure-works.com";
XElement root = new XElement(aw + "Root",
    new XAttribute("xmlns", "http://www.adventure-works.com"),
    new XElement(aw + "Child", "content")
);
Console.WriteLine(root);

Dim aw As XNamespace = "http://www.adventure-works.com"
Dim root As XElement = New XElement(aw + "Root", _
    New XAttribute("xmlns", "http://www.adventure-works.com"), _
    New XElement(aw + "Child", "content") _
)
Console.WriteLine(root)

Dans Visual Basic, au lieu de créer un nœud d’espace de noms pour créer un espace de noms par défaut, vous utilisez généralement une déclaration d’espace de noms globale par défaut :

Imports <xmlns='http://www.adventure-works.com'>

Module Module1
    Sub Main()
        Dim root As XElement = _
            <Root>
                <Child>content</Child>
            </Root>
        Console.WriteLine(root)
    End Sub
End Module

Cet exemple génère la sortie suivante :

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

Atomisation de XNamespace

XNamespace les objets sont garantis d'être atomisés ; c'est-à-dire que si deux XNamespace objets ont exactement le même URI, ils partageront la même instance. Les opérateurs d’égalité et de comparaison sont fournis explicitement à cet effet.

Utiliser des noms développés

Une autre façon de spécifier un espace de noms et un nom local consiste à utiliser un nom développé dans le formulaire {namespace}name:

XElement e = new XElement("{http://www.adventure-works.com}Root",
     new XAttribute("{http://www.adventure-works.com}Att", "content")
);
Console.WriteLine(e);

Dim e As XElement = New XElement("{http://www.adventure-works.com}Root", _
     New XAttribute("{http://www.adventure-works.com}Att", "content") _
)
Console.WriteLine(e)

Cet exemple génère la sortie suivante :

<Root p1:Att="content" xmlns:p1="http://www.adventure-works.com" xmlns="http://www.adventure-works.com" />

Cette approche a des implications sur les performances. Chaque fois que vous passez une chaîne qui contient un nom développé à LINQ to XML, elle doit analyser le nom, rechercher l’espace de noms atomisé et trouver le nom atomisé. Ce processus prend du temps de CPU. Si les performances sont importantes, vous pouvez utiliser une approche différente.

Avec Visual Basic, l’approche recommandée consiste à utiliser des littéraux XML, qui n’impliquent pas l’utilisation de noms développés.