6. Espaces de noms

Ils sont définis dans des fichiers, organisés en espaces de noms (namespace), compilés dans un module, puis groupés dans une assemblée. Ces unités d'organisations sont découpées. Par exemple, un groupe d'espaces de noms est défini sur une assemblée, mais un simple espace de noms peut en fait s'étendre sur de multiples assemblées.

6.1. Fichiers

L'organisation des fichiers est quasiment insignifiante pour le compilateur C#, un projet entier peut être fusionné en un seul fichier .cs et pourra tout de même être compilé (les instructions du préprocesseur sont les seules exceptions à cela). Toutefois, il est généralement plus ordonné d'avoir un type par fichier, avec le nom du fichier qui corresponde au nom de la classe et le répertoire du fichier qui corresponde à l'espace de noms de la classe.

6.2. Utiliser les espaces de noms

Un espace de noms vous permet de grouper des types en relations en une catégorisation hiérarchique. Généralement, le premier nom est le nom de votre entreprise.
Code Résultat Remarques 
using System;

namespace Alliance.Dessin
{
    class Point
    {
        // propriétés
        public int x, y, z;

        // constructeur
        public Point(int ax, int ay, int az)
        {
            x = ax;
            y = ay;
            z = az;
        }

        // affichage des propriétés
        public void AfficheProprietes()
        {
            Console.WriteLine("x = " + x + ", y = " + y + " et z = " + z);
        }
    }
}

namespace Exemples
{
    class UtiliserEspacesNoms
    {
        static void Main(string[] args)
        {
            Alliance.Dessin.Point P = new Alliance.Dessin.Point(1, 2, 3);
            P.AfficheProprietes(); // affiche x = 1, y = 2 et z = 3
            Console.ReadKey();
        }
    }
}
 
x = 1, y = 2 et z = 3
 Dans cet exemple, on utilise la classe Alliance.Dessin.Point...

6.3. Emboîter les espaces de noms

Vous pouvez également emboîter les espaces de noms au lieu d'utiliser des points.
Code Résultat Remarques 
using System;

namespace Alliance
{
    namespace Dessin
    {
        class Point
        {
            // propriétés
            public int x, y, z;

            // constructeur
            public Point(int ax, int ay, int az)
            {
                x = ax;
                y = ay;
                z = az;
            }

            // affichage des propriétés
            public void AfficheProprietes()
            {
                Console.WriteLine("x = " + x + ", y = " + y + " et z = " + z);
            }
        }
    }
}

namespace Exemples
{
    class EmboiterEspacesNom
    {
        static void Main(string[] args)
        {
            Alliance.Dessin.Point P = new Alliance.Dessin.Point(1, 2, 3);
            P.AfficheProprietes(); // affiche x = 1, y = 2 et z = 3
            Console.ReadKey();
        }
    }
}

x = 1, y = 2 et z = 3
 Cet exemple est sémantiquement identique au précédent...

6.4. Utiliser un type avec son nom pleinement qualifié

Pour utiliser la classe Point (définie dans les deux exemples précédents), d'un autre espace de noms, vous pouvez vous référer à son nom pleinement qualifié.
L'espace de nom d'un type donné fait partie du nom de ce type.
Dans les deux exemples précédents, nous déclarons un Point dans l'espace de nom Exemples de la façon suivante : 
Alliance.Dessin.Point P = new Alliance.Dessin.Point(1, 2, 3);

6.5. Le mot-clé using

Le mot-clé using est une manière commode pour éviter d'utiliser le nom pleinement qualifié des types d'autres espaces de noms.
Code Résultat Remarques 
using System;

namespace Alliance.Dessin
{
    class Point
    {
        // propriétés
        public int x, y, z;

        // constructeur
        public Point(int ax, int ay, int az)
        {
            x = ax;
            y = ay;
            z = az;
        }

        // affichage des propriétés
        public void AfficheProprietes()
        {
            Console.WriteLine("x = " + x + ", y = " + y + " et z = " + z);
        }
    }
}

namespace Exemples
{
    using Alliance.Dessin;
    class MotCleUsing
    {
        static void Main(string[] args)
        {
            Point P = new Point(1, 2, 3);
            P.AfficheProprietes(); // affiche x = 1, y = 2 et z = 3
            Console.ReadKey();
        }
    }
}
 
x = 1, y = 2 et z = 3
 Cet exemple est sémantiquement identique aux précédents...

6.6. Alias de types et d'espaces de noms

Les noms des types doivent être uniques à l'intérieur d'un espace de noms.
Pour éviter tout conflit et d'avoir à utiliser le nom pleinement qualifier, C# vous permet de spécifier un alias pour un type ou un espace de noms.
Code Résultat Remarques 
using sys = System; // alias d'espace de noms
using txt = System.String; // alias de type

namespace Exemples
{
    class AliasTypesEspacesNoms
    {
        static void Main(string[] args)
        {
            txt s = "Bonjour tout le monde !";
            sys.Console.WriteLine(s); // affiche Bonjour tout le monde !
            sys.Console.WriteLine(s.GetType()); // affiche System.String
            sys.Console.ReadKey();
        }
    }
}
 
Bonjour tout le monde !
System.String
 Voici un exemple d'utilisation des alias...

6.7. Espace de noms global

L'espace de noms global est le niveau le plus haut dans lequel tous les espaces de noms et les types sont implicitement déclarés. Lorsqu'un type n'est pas explicitement déclaré dans un espace de noms, il peut être utilisé sans qualificatrion depuis un autre espace de noms, puisqu'il est membre de l'espace de noms global. Toutefois, excepté pour les plus petits programmes, il est toujours bon d'agencer les types à l'intérieur d'espaces de noms de manière logique.
Code Résultat Remarques 
using System;

class Point
{
    // propriétés
    public int x, y, z;

    // constructeur
    public Point(int ax, int ay, int az)
    {
        x = ax;
        y = ay;
        z = az;
    }

    // affichage des propriétés
    public void AfficheProprietes()
    {
        Console.WriteLine("x = " + x + ", y = " + y + " et z = " + z);
    }
}

namespace Exemples
{
    class EspaceNomsGlobal
    {
        static void Main(string[] args)
        {
            Point P = new Point(1, 2, 3);
            P.AfficheProprietes(); // affiche x = 1, y = 2 et z = 3
            Console.ReadKey();
        }
    }
}
 
x = 1, y = 2 et z = 3
 Dans cet exemple, la classe Point est déclarée dans l'espace global, ainsi elle peut être utilisée sans qualification de l'espace de noms Exemples.