Programmation C sharp/Les espaces de noms

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche
Programmation C#
Programmation C#
Sommaire
Le langage
Programmation avancée
API .Net
Ressources
Modifier ce modèle

Définition[modifier | modifier le wikicode]

Un espace de nom regroupe plusieurs déclarations sous un même nom ajouté à ceux des éléments déclarés (classes, interfaces, espace de nom imbriqué).

Exemple :

namespace MesClasses
{
    public class ClasseUne
    { ... }

    public class ClasseDeux
    { ... }
}

Utiliser les membres d'un espace de nom[modifier | modifier le wikicode]

Les classes définies à l'intérieur de cet espace de noms peuvent se faire référence par leur nom simple : ClasseUne, ClasseDeux.

Une classe membre d'un autre espace de nom ou d'aucun doit forcément utiliser le nom absolu des classes, c'est à dire : MesClasses.ClasseUne, MesClasses.ClasseDeux ou bien utiliser la directive using :

using namespace;

Exemple :

using MesClasses;

public class ClasseTest
{
    ClasseUne objet1;
    ClasseDeux objet2;
}

Équivaut à :

public class ClasseTest
{
    MesClasses.ClasseUne objet1;
    MesClasses.ClasseDeux objet2;
}

L'exemple du chapitre "Un premier programme" utilise déjà un espace de nom : la classe Console est définie dans l'espace de noms System.

Imbrication des espaces de noms[modifier | modifier le wikicode]

L'imbrication des espaces de noms est possible :

namespace MesClasses
{
    namespace Calcul
    {
        ... // espace de nom  MesClasses.Calcul
    }
}

Ou directement :

namespace MesClasses.Calcul
{
    ... // espace de nom  MesClasses.Calcul
}

Espace de noms en plusieurs parties[modifier | modifier le wikicode]

Plusieurs fichiers sources peuvent contribuer à ajouter des déclarations à un même espace de noms.

Exemple :

Crystal128-txt.svg images.cs
Classes de gestion des images dans l'espace de noms Exemple.Graphisme
using System;
namespace Exemple.Graphisme
{
    public class Image { ... }
    public class ImageBitmap : Image { ... }
    ...
}


Crystal128-txt.svg couleur.cs
Classes de gestion des couleurs dans l'espace de noms Exemple.Graphisme
using System;
namespace Exemple.Graphisme
{
    public class Couleur { ... }
    public class ConversionCouleur { ... }
    ...
}


Alias d'espace de nom[modifier | modifier le wikicode]

Le mot clé using peut servir à assigner un autre nom (plus court en général) à un espace de nom.

Exemple :

using coll = System.Collections;

public class Exemple
{
    coll::Hashtable donnees = new coll::Hashtable();
}

Créer un alias d'espace de nom est également utile pour utiliser deux classes portant le même nom, situées dans deux espaces de nom différents.

Exemple :

namespace Gestion.Transport
{
    public class Ligne { ... }
}

namespace Graphique.Dessin
{
    public class Ligne { ... }
}

Si l'instruction using est utilisée deux fois, le nom Ligne est ambigu, comme l'explique l'erreur produite par le compilateur :

using Gestion.Transport;
using Graphique.Dessin;

public class Exemple
{
    Ligne exemple;
    // -> error CS0104: 'Ligne' is an ambiguous reference between
    //    'Gestion.Transport.Ligne' and 'Graphique.Dessin.Ligne'.
}

Dans ce cas, on peut utiliser l'instruction using pour l'un des deux espaces de nom et utiliser le nom complet pour l'autre espace de nom :

using Gestion.Transport;

public class Exemple
{
    Ligne transport;
    Graphique.Dessin.Ligne trace;
}

Il est également possible de définir deux alias d'espace de nom afin d'abréger les références :

using transport=Gestion.Transport;
using dessin=Graphique.Dessin;

public class Exemple
{
    transport::Ligne transport;
    dessin::Ligne trace;
}

Conflit de nom[modifier | modifier le wikicode]

Il est possible que le code source utilise des noms déjà utilisé comme espace de noms.

Dans l'exemple de code suivant, les noms System et Console font référence à des attributs de la classe Classe.

public class Classe
{
    private string System = "system";
    private string Console = "console";

    public void Afficher()
    {
        // System.Console.WriteLine("Exemple"); // provoque une erreur
    }
}

Il est toutefois possible d'utiliser System.Console en utilisant le préfixe global:: qui permet de spécifier que l'on accède à l'espace de nom racine de tous les autres (implicite par défaut) :

public class Classe
{
    private string System = "system";
    private string Console = "console";

    public void Afficher()
    {
        global::System.Console.WriteLine("Exemple"); // OK
    }
}

Alias d'assemblages[modifier | modifier le wikicode]

Lorsqu'une application utilise des assemblages dont les noms de classes complets (espace de nom inclus) sont identiques (deux versions/implémentations d'une même classe), l'ambiguïté doit être résolue en utilisant des alias d'assemblages.

Pour utiliser deux versions d'une même classe définies dans les assemblages grid.dll (version 1.0, alias "GridV1") et grid20.dll (version 2.0, alias "GridV2"), il faut définir les alias à utiliser dans la ligne de commande de compilation :

Windows csc /r:GridV1=grid.dll /r:GridV2=grid20.dll ...
Linux (Mono) gmsc -r:GridV1=grid.dll -r:GridV2=grid20.dll ...


Cela crée les alias externes GridV1 et GridV2. Pour utiliser ces alias à partir d'un programme, il faut les référencer à l'aide du mot clé extern :

extern alias GridV1;
extern alias GridV2;

Ces deux instructions créent deux nouvelles racines d'espace de nom en plus de global :

extern alias GridV1;
extern alias GridV2;

public class Exemple
{
    GridV1::Grid grid_v1; // implémentation V1.0 (grid.dll)
    GridV2::Grid grid_v2; // implémentation V2.0 (grid20.dll)
}