XNamespace Classe

Définition

Représente un espace de noms XML.Represents an XML namespace. Cette classe ne peut pas être héritée.This class cannot be inherited.

public ref class XNamespace sealed
public sealed class XNamespace
type XNamespace = class
Public NotInheritable Class XNamespace
Héritage
XNamespace

Remarques

This class represents the XML construct of namespaces.

Chaque XName contient un XNamespace .Every XName contains an XNamespace. Même si un élément n'est pas dans un espace de noms, l'objet XName de l'élément contient un espace de noms, XNamespace.None.Even if an element is not in a namespace, the element's XName still contains a namespace, XNamespace.None. La propriété XName.Namespace est assurée de ne pas être null.The XName.Namespace property is guaranteed to not be null.

Création d’un objet XNamespaceCreating an XNamespace Object

La méthode la plus courante pour créer un XNamespace objet consiste simplement à lui assigner une chaîne.The most common way to create an XNamespace object is to simply assign a string to it. Vous pouvez ensuite combiner l’espace de noms avec un nom local à l’aide de la substitution de l’opérateur d’addition.You can then combine the namespace with a local name by using the override of the addition operator. L’exemple suivant illustre cet idiome :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)  

Toutefois, dans Visual Basic, vous déclarez généralement un espace de noms global par défaut, comme suit :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  

Cet exemple génère la sortie suivante :This example produces the following output:

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

L’assignation d’une chaîne à un XNamespace utilise la conversion implicite de String .Assigning a string to an XNamespace uses the implicit conversion from String.

Pour plus d’informations et des exemples, consultez comment créer un document avec des espaces de noms en C# (LINQ to XML) .See How to create a document with namespaces in C# (LINQ to XML) for more information and examples.

Pour plus d’informations sur l’utilisation des espaces de noms dans Visual Basic, consultez utiliser des espaces de noms XML .See Work with XML namespaces for more information on using namespaces in Visual Basic.

Contrôle des préfixes d’espaces de nomsControlling Namespace Prefixes

Si vous créez un attribut qui déclare un espace de noms, le préfixe spécifié dans l’attribut sera rendu persistant dans le XML sérialisé.If you create an attribute that declares a namespace, the prefix specified in the attribute will be persisted in the serialized XML. Pour créer un attribut qui déclare un espace de noms avec un préfixe, vous devez créer un attribut où l'espace de noms du nom de l'attribut est Xmlns et le nom de l'attribut est le préfixe d'espace de noms.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. La valeur de l'attribut est l'URI de l'espace de noms.The value of the attribute is the URI of the namespace. L’exemple suivant illustre cet idiome :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)  

Dans Visual Basic, au lieu de créer un nœud d’espace de noms pour contrôler les préfixes d’espaces de noms, vous devez généralement utiliser une déclaration d’espace de noms globale :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  

Cet exemple génère la sortie suivante :This example produces the following output:

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

Pour plus d’informations, consultez Guide pratique pour contrôler les préfixes d’espaces de noms.For more information, see How to control namespace prefixes.

Création d’un espace de noms par défautCreating a Default Namespace

Lors de la construction d’un attribut qui sera un espace de noms, si le nom de l’attribut a la valeur spéciale « xmlns », alors, lorsque l’arborescence XML est sérialisée, l’espace de noms est déclaré en tant qu’espace de noms par défaut.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. L’attribut spécial portant le nom « xmlns » lui-même ne se trouve dans aucun espace de noms.The special attribute with the name of "xmlns" itself is not in any namespace. La valeur de l’attribut est l’URI de l’espace de noms.The value of the attribute is the namespace URI.

L’exemple suivant crée une arborescence XML qui contient un attribut qui est déclaré de manière à ce que l’espace de noms devienne l’espace de noms par défaut :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)  

Dans Visual Basic, au lieu de créer un nœud d’espace de noms pour créer un espace de noms par défaut, vous devez généralement utiliser une déclaration d’espace de noms par défaut globale :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  

Cet exemple génère la sortie suivante :This example produces the following output:

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

Atomisation XNamespaceXNamespace Atomization

XNamespace les objets sont assurément atomisés ; autrement dit, si deux XNamespace objets ont exactement le même URI, ils partageront la même instance.XNamespace objects are guaranteed to be atomized; that is, if two XNamespace objects have exactly the same URI, they will share the same instance. Les opérateurs d’égalité et de comparaison sont fournis explicitement à cet effet.The equality and comparison operators are provided explicitly for this purpose.

Utilisation de noms développésUsing Expanded Names

Pour spécifier un espace de noms et un nom local, vous pouvez également utiliser un nom développé au format {namespace}name suivant :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)  

Cet exemple génère la sortie suivante :This example produces the following output:

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

Cette approche a des implications en termes de performances.This approach has performance implications. Chaque fois que vous passez une chaîne qui contient un nom développé à LINQ to XMLLINQ to XML, il doit analyser le nom, rechercher l’espace de noms atomisé et rechercher le nom atomisé.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. Ce processus consomme du temps de processeur.This process takes CPU time. Si les performances sont importantes, vous souhaiterez peut-être utiliser une approche différente.If performance is important, you may want to use a different approach.

Avec Visual Basic, l’approche recommandée consiste à utiliser des littéraux XML, qui n’impliquent pas l’utilisation de noms développés.With Visual Basic, the recommended approach is to use XML literals, which does not involve the use of expanded names.

Propriétés

NamespaceName

Obtient l'URI (Uniform Resource Identifier) de cet espace de noms.Gets the Uniform Resource Identifier (URI) of this namespace.

None

Obtient l'objet XNamespace qui ne correspond à aucun espace de noms.Gets the XNamespace object that corresponds to no namespace.

Xml

Obtient l’objet XNamespace qui correspond à l’URI 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

Obtient l’objet XNamespace qui correspond à l’URI xmlns (http://www.w3.org/2000/xmlns/).Gets the XNamespace object that corresponds to the xmlns URI (http://www.w3.org/2000/xmlns/).

Méthodes

Equals(Object)

Détermine si l'objet XNamespace spécifié est égal à l'objet XNamespace actuel.Determines whether the specified XNamespace is equal to the current XNamespace.

Get(String)

Obtient un XNamespace pour l'URI (Uniform Resource Identifier) spécifié.Gets an XNamespace for the specified Uniform Resource Identifier (URI).

GetHashCode()

Obtient un code de hachage pour ce XNamespace.Gets a hash code for this XNamespace.

GetName(String)

Retourne un objet XName créé à partir de ce XNamespace et du nom local spécifié.Returns an XName object created from this XNamespace and the specified local name.

GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Retourne l'URI de ce XNamespace.Returns the URI of this XNamespace.

Opérateurs

Addition(XNamespace, String)

Combine un objet XNamespace avec un nom local pour créer un XName.Combines an XNamespace object with a local name to create an XName.

Equality(XNamespace, XNamespace)

Retourne une valeur indiquant si deux instances de XNamespace sont égales.Returns a value indicating whether two instances of XNamespace are equal.

Implicit(String to XNamespace)

Convertit une chaîne contenant un URI (Uniform Resource Identifier) en XNamespace.Converts a string containing a Uniform Resource Identifier (URI) to an XNamespace.

Inequality(XNamespace, XNamespace)

Retourne une valeur indiquant si deux instances de XNamespace ne sont pas égales.Returns a value indicating whether two instances of XNamespace are not equal.

S’applique à

Voir aussi