XNamespace Classe

Definição

Representa um namespace de XML.Represents an XML namespace. Essa classe não pode ser herdada.This class cannot be inherited.

public ref class XNamespace sealed
public sealed class XNamespace
type XNamespace = class
Public NotInheritable Class XNamespace
Herança
XNamespace

Comentários

Essa classe representa a construção XML de namespaces.This class represents the XML construct of namespaces.

Cada XName contém um XNamespace.Every XName contains an XNamespace. Mesmo que um elemento não esteja em um namespace, o elemento XName ainda contém um namespace,. XNamespace.NoneEven if an element is not in a namespace, the element's XName still contains a namespace, XNamespace.None. A XName.Namespace propriedadenullnão é garantida.The XName.Namespace property is guaranteed to not be null.

Criando um objeto XNamespaceCreating an XNamespace Object

A maneira mais comum de criar um XNamespace objeto é simplesmente atribuir uma cadeia de caracteres a ele.The most common way to create an XNamespace object is to simply assign a string to it. Em seguida, você pode combinar o namespace com um nome local usando a substituição do operador de adição.You can then combine the namespace with a local name by using the override of the addition operator. O exemplo a seguir mostra esse idioma:The following example shows this idiom:

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:However, in Visual Basic, you would typically declare a global default namespace, as follows:

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 gera a seguinte saída:This example produces the following output:

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

A atribuição de uma cadeia de caracteres XNamespace a uma usa a conversão Stringimplícita do.Assigning a string to an XNamespace uses the implicit conversion from String.

Confira Como Crie um documento com namespaces (C#) (LINQ to XML) para obter mais informações e exemplos.See How to: Create a Document with Namespaces (C#) (LINQ to XML) for more information and examples.

Consulte namespaces em Visual Basic (LINQ to XML) para obter mais informações sobre como usar namespaces no Visual Basic.See Namespaces in Visual Basic (LINQ to XML) for more information on using namespaces in Visual Basic.

Controlando prefixos de namespaceControlling Namespace Prefixes

Se você criar um atributo que declara um namespace, o prefixo especificado no atributo será persistido no XML serializado.If you create an attribute that declares a namespace, the prefix specified in the attribute will be persisted in the serialized XML. 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.To create an attribute that declares a namespace with a prefix, you create an attribute where the namespace of the name of the attribute is Xmlns, and the name of the attribute is the namespace prefix. O valor do atributo é o URI do namespace.The value of the attribute is the URI of the namespace. O exemplo a seguir mostra esse idioma:The following example shows this idiom:

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)  

Em Visual Basic, em vez de criar um nó de namespace para controlar prefixos de namespace, você normalmente usaria uma declaração de namespace global:In Visual Basic, instead of creating a namespace node to control namespace prefixes, you would typically use a global namespace declaration:

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 gera a seguinte saída:This example produces the following output:

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

Para obter mais informações, confira Como: Prefixos de namespaceC#de controle ()(LINQ to XML).For more information, see How to: Control Namespace Prefixes (C#) (LINQ to XML).

Criando um namespace padrãoCreating a Default Namespace

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.When constructing an attribute that will be a namespace, if the attribute name has the special value of "xmlns", then when the XML tree is serialized, the namespace will be declared as the default namespace. O atributo especial com o nome "xmlns" em si não está em nenhum namespace.The special attribute with the name of "xmlns" itself is not in any namespace. O valor do atributo é o URI do namespace.The value of the attribute is the namespace URI.

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:The following example creates an XML tree that contains an attribute that is declared in such a way that the namespace will become the default namespace:

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)  

Em 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:In Visual Basic, instead of creating a namespace node to create a default namespace, you would typically use a global default namespace declaration:

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 gera a seguinte saída:This example produces the following output:

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

XNamespace de atomizaçãoXNamespace Atomization

XNamespaceos objetos são garantidos para serem atomos; ou seja, se dois XNamespace objetos tiverem exatamente o mesmo URI, eles compartilharão a mesma instância.XNamespace objects are guaranteed to be atomized; that is, if two XNamespace objects have exactly the same URI, they will share the same instance. Os operadores de igualdade e comparação são fornecidos explicitamente para essa finalidade.The equality and comparison operators are provided explicitly for this purpose.

Usando nomes expandidosUsing Expanded Names

Outra maneira de especificar um namespace e um nome local é usar um nome expandido no formato {namespace}name:Another way to specify a namespace and a local name is to use an expanded name in the form {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 gera a seguinte saída:This example produces the following output:

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

Essa abordagem tem implicações de desempenho.This approach has performance implications. Cada vez que você passa uma cadeia de caracteres que contém um nome LINQ to XMLLINQ to XMLexpandido para, ele deve analisar o nome, localizar o namespace estendido e encontrar o nome atomado.Each time that you pass a string that contains an expanded name to LINQ to XMLLINQ to XML, it must parse the name, find the atomized namespace, and find the atomized name. Esse processo utiliza tempo de CPU.This process takes CPU time. Se o desempenho for importante, talvez você queira usar uma abordagem diferente.If performance is important, you may want to use a different approach.

Com o Visual Basic, a abordagem recomendada é usar literais XML, que não envolve o uso de nomes expandidos.With Visual Basic, the recommended approach is to use XML literals, which does not involve the use of expanded names.

Propriedades

NamespaceName

Obtém o URI (Uniform Resource Identifier) deste namespace.Gets the Uniform Resource Identifier (URI) of this namespace.

None

Obtém o objeto XNamespace que não corresponde a nenhum namespace.Gets the XNamespace object that corresponds to no namespace.

Xml

Obtém o objeto XNamespace correspondente ao URI do XML (http://www.w3.org/XML/1998/namespace).Gets the XNamespace object that corresponds to the XML URI (http://www.w3.org/XML/1998/namespace).

Xmlns

Obtém o objeto XNamespace que corresponde ao URI do xmlns (http://www.w3.org/2000/xmlns/).Gets the XNamespace object that corresponds to the xmlns URI (http://www.w3.org/2000/xmlns/).

Métodos

Equals(Object)

Determina se o XNamespace especificado é igual ao XNamespace atual.Determines whether the specified XNamespace is equal to the current XNamespace.

Get(String)

Obtém um XNamespace para o URI (Uniform Resource Identifier) especificado.Gets an XNamespace for the specified Uniform Resource Identifier (URI).

GetHashCode()

Obtém o código hash para esse XNamespace.Gets a hash code for this XNamespace.

GetName(String)

Retorna um objeto XName criado com base neste XNamespace e o nome do local especificado.Returns an XName object created from this XNamespace and the specified local name.

GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
ToString()

Retorna o URI desse XNamespace.Returns the URI of this XNamespace.

Operadores

Addition(XNamespace, String)

Combina um objeto XNamespace com um nome local para criar um XName.Combines an XNamespace object with a local name to create an XName.

Equality(XNamespace, XNamespace)

Retorna um valor que indica se duas instâncias de XNamespace são iguais.Returns a value indicating whether two instances of XNamespace are equal.

Implicit(String to XNamespace)

Converte uma cadeia de caracteres que contém um URI (Uniform Resource Identifier) em um XNamespace.Converts a string containing a Uniform Resource Identifier (URI) to an XNamespace.

Inequality(XNamespace, XNamespace)

Retorna um valor que indica se duas instâncias de XNamespace não são iguais.Returns a value indicating whether two instances of XNamespace are not equal.

Aplica-se a

Veja também