XNamespace Classe

Definizione

public ref class XNamespace sealed

public sealed class XNamespace

type XNamespace = class

Public NotInheritable Class XNamespace

Ereditarietà

Object

XNamespace

Commenti

Questa classe rappresenta il costrutto XML del namespace.

Ogni XName oggetto contiene un oggetto XNamespace. Anche se un elemento non si trova in uno spazio dei nomi, l'elemento XName contiene ancora uno spazio dei nomi , XNamespace.None. La proprietà XName.Namespace è garantita per non essere 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

In questo esempio viene generato 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, creare un attributo in cui lo spazio dei nomi del nome dell'attributo è Xmlnse 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

In questo esempio viene generato 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

In questo esempio viene generato 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 di confronto sono forniti esplicitamente per 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)

In questo esempio viene generato l'output seguente:

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

Questo approccio ha implicazioni 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 richiede tempo per la 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.

Vedi anche

• Panoramica di LINQ to XML