XNamespace Classe

Definição

public ref class XNamespace sealed

public sealed class XNamespace

type XNamespace = class

Public NotInheritable Class XNamespace

Herança

Object

XNamespace

Observações

Esta classe representa a construção XML de namespaces.

Cada XName contém um XNamespace. Mesmo que um elemento não esteja em um namespace, o elemento XName ainda contém um namespace, XNamespace.None. A XName.Namespace propriedade é garantida para não ser null.

Criar um objeto XNamespace

A maneira mais comum de criar um XNamespace objeto é simplesmente atribuir uma cadeia de caracteres a ele. Em seguida, você pode combinar o namespace com um nome local usando a substituição do operador de adição. O exemplo a seguir mostra essa linguagem:

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)

No entanto, no Visual Basic, você normalmente declararia um namespace padrão global, da seguinte maneira:

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

Este exemplo produz a seguinte saída:

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

Atribuir uma cadeia de caracteres a um XNamespace usa a conversão implícita de String.

Consulte Como criar um documento com namespaces em C# (LINQ to XML) para obter mais informações e exemplos.

Consulte Trabalhar com namespaces XML para obter mais informações sobre como usar namespaces no Visual Basic.

Controlar prefixos de namespace

Se você criar um atributo que declare um namespace, o prefixo especificado no atributo será persistido no XML serializado. Para criar um atributo que declara um namespace com um prefixo, crie um atributo onde o namespace do nome do atributo é Xmlns, e o nome do atributo é o prefixo do namespace. O valor do atributo é o URI do namespace. O exemplo a seguir mostra essa linguagem:

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)

No Visual Basic, em vez de criar um nó de namespace para controlar prefixos de namespace, você normalmente usaria uma declaração de namespace global:

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

Este exemplo produz a seguinte saída:

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

Para obter mais informações, consulte Como controlar prefixos de namespace.

Criar um namespace padrão

Ao construir um atributo que será um namespace, se o nome do atributo tiver o valor especial de "xmlns", quando a árvore XML for serializada, o namespace será declarado como o namespace padrão. O atributo especial com o nome de "xmlns" em si não está em nenhum namespace. O valor do atributo é o URI do namespace.

O exemplo a seguir cria uma árvore XML que contém um atributo que é declarado de tal forma que o namespace se tornará o namespace padrão:

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)

No Visual Basic, em vez de criar um nó de namespace para criar um namespace padrão, você normalmente usaria uma declaração de namespace padrão global:

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

Este exemplo produz a seguinte saída:

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

Atomização de XNamespace

XNamespace é garantido que os objetos sejam atomizados; ou seja, se dois XNamespace objetos tiverem exatamente o mesmo URI, eles compartilharão a mesma instância. Os operadores de igualdade e comparação são fornecidos explicitamente para este fim.

Usar nomes expandidos

Outra maneira de especificar um namespace e um nome local é usar um nome expandido no formato {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)

Este exemplo produz a seguinte saída:

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

Esta abordagem tem implicações no desempenho. Cada vez que você passa uma cadeia de caracteres que contém um nome expandido para LINQ to XML, ele deve analisar o nome, localizar o namespace atomizado e localizar o nome atomizado. Este processo leva tempo de CPU. Se o desempenho for importante, convém usar uma abordagem diferente.

Com o Visual Basic, a abordagem recomendada é usar literais XML, que não envolvem o uso de nomes expandidos.

Ver também

• Visão geral do LINQ to XML