Classe System.Xml.Linq.XNamespace

Questo articolo fornisce osservazioni supplementari alla documentazione di riferimento per questa API.

Questa classe rappresenta il costrutto XML degli spazi dei nomi.

Ogni XName oggetto contiene un oggetto XNamespace. Anche se un elemento non è incluso in uno spazio dei nomi, l'oggetto XName dell'elemento contiene comunque uno spazio dei nomi, XNamespace.None. La proprietà XName.Namespace non è null.

Creare un oggetto XNamespace

Il modo più comune per creare un XNamespace oggetto consiste nell'assegnare semplicemente una stringa. È quindi possibile combinare lo spazio dei nomi con un nome locale usando l'override dell'operatore di addizione. L'esempio seguente illustra questo linguaggio:

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)

In Visual Basic, tuttavia, in genere si dichiara uno spazio dei nomi predefinito globale, come indicato di seguito:

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

Nell'esempio viene prodotto l'output seguente:

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

L'assegnazione di una stringa a un XNamespace usa la conversione implicita da String.

Per altre informazioni ed esempi, vedere Come creare un documento con spazi dei nomi in C# (LINQ to XML).

Per altre informazioni sull'uso degli spazi dei nomi in Visual Basic, vedere Usare gli spazi dei nomi XML.

Controllare i prefissi dello spazio dei nomi

Se si crea un attributo che dichiara uno spazio dei nomi, il prefisso specificato nell'attributo verrà salvato in modo permanente nel codice XML serializzato. Per creare un attributo che dichiara uno spazio dei nomi con un prefisso, viene creato un attributo in cui lo spazio dei nomi del nome dell'attributo è Xmlns e il nome dell'attributo è il prefisso dello spazio dei nomi. Il valore dell'attributo è l'URI dello spazio dei nomi. L'esempio seguente illustra questo linguaggio:

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)

In Visual Basic anziché creare un nodo dello spazio dei nomi per controllare i prefissi dello spazio dei nomi, in genere si usa una dichiarazione dello spazio dei nomi 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

Nell'esempio viene prodotto l'output seguente:

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

Per altre informazioni, vedere Come controllare i prefissi dello spazio dei nomi.

Creare uno spazio dei nomi predefinito

Quando si costruisce un attributo che sarà uno spazio dei nomi, se il nome dell'attributo ha il valore speciale "xmlns", quando l'albero XML viene serializzato, lo spazio dei nomi verrà dichiarato come spazio dei nomi predefinito. L'attributo speciale con il nome "xmlns" stesso non si trova in alcuno spazio dei nomi. Il valore dell'attributo è l'URI dello spazio dei nomi.

Nell'esempio seguente viene creato un albero XML contenente un attributo dichiarato in modo che lo spazio dei nomi diventi lo spazio dei nomi predefinito:

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)

In Visual Basic anziché creare un nodo dello spazio dei nomi per creare uno spazio dei nomi predefinito, in genere si usa una dichiarazione dello spazio dei nomi predefinita globale:

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

Nell'esempio viene prodotto l'output seguente:

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

Atomizzazione XNamespace

XNamespace gli oggetti sono sicuramente atomizzati; ovvero, se due XNamespace oggetti hanno esattamente lo stesso URI, condivideranno la stessa istanza. Gli operatori di uguaglianza e confronto vengono forniti in modo esplicito a questo scopo.

Usare nomi espansi

Un altro modo per specificare uno spazio dei nomi e un nome locale consiste nell'usare un nome espanso nel 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)

Nell'esempio viene prodotto l'output seguente:

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

Questo approccio può tuttavia incidere sulle prestazioni. Ogni volta che si passa una stringa che contiene un nome espanso a LINQ to XML, deve analizzare il nome, trovare lo spazio dei nomi atomizzato e trovare il nome atomizzato. Questo processo impiega il tempo della CPU. Se le prestazioni sono importanti, è consigliabile usare un approccio diverso.

Con Visual Basic, l'approccio consigliato consiste nell'usare valori letterali XML, che non implicano l'uso di nomi espansi.