Classe System.Xml.Linq.XNamespace

Este artigo fornece observações complementares à documentação de referência para essa API.

Essa 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 XName do elemento ainda contém um namespace, XNamespace.None. A propriedade XName.Namespace é garantida para não ser null.

Criar um objeto de XNamespace

A maneira mais comum de criar um objeto XNamespace é 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 seguinte exemplo mostra essa expressão:

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

Esse exemplo gera a saída a seguir:

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

A atribuição de uma cadeia de caracteres a um XNamespace usa a conversão implícita do String.

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

Consulte Trabalhar com namespaces de 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 declare um namespace com um prefixo, você cria 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 seguinte exemplo mostra essa expressão:

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

Esse exemplo gera a saída a seguir:

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

Para obter mais informações, consulte Como controlar os 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 de 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 de 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

Esse exemplo gera a saída a seguir:

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

Atomização de XNamespace

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

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)

Esse exemplo gera a saída a seguir:

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

Essa abordagem tem implicações de desempenho. Toda vez que você passa uma cadeia de caracteres que contém um nome expandido para o LINQ to XML, o LINQ to XML deve analisar o nome, localizar o namespace atomizado e localizar o nome atomizado. Esse processo utiliza tempo de CPU. Se o desempenho for importante, talvez você queira usar uma abordagem diferente.

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