Utilisation d'espaces de noms (Guide de programmation C#)

Article
08/10/2011

Les espaces de noms sont énormément employés dans les programmes C# de deux manières. Premièrement, les classes .NET Framework utilisent des espaces de noms pour organiser ses nombreuses classes. Deuxièmement, déclarer ses propres espaces de noms peut aider à contrôler la portée des noms de classes et de méthodes dans les projets de programmation plus volumineux.

Accès aux espaces de noms

La plupart des applications C# commencent par une section de directives using. Cette section répertorie les espaces de noms que l'application utilisera fréquemment, et évite au programmeur de devoir spécifier un nom qualifié complet chaque fois qu'une méthode contenue à l'intérieur est utilisée.

Par exemple, en incluant la ligne :

using System;

Au démarrage d'un programme, le programmeur peut utiliser le code :

Console.WriteLine("Hello, World!");

à la place de :

System.Console.WriteLine("Hello, World!");

Alias d'espaces de noms

Les using, directive (référence C#) peuvent également permettre de créer un alias pour un espace de noms. Par exemple, si vous utilisez un espace de noms écrit qui contient des espaces de noms imbriqués, déclarer un alias vous offre un moyen pratique d'en référencer un en particulier, comme suit :

using Co = Company.Proj.Nested;  // define an alias to represent a namespace

Utilisation d'espaces de noms pour contrôler la portée

Le mot clé namespace permet de déclarer une portée. La capacité de créer des portées dans votre projet aide à organiser le code et vous permet de créer des types globalement uniques. Dans l'exemple suivant, une classe intitulée SampleClass est définie dans deux espaces de noms, l'une étant imbriquée dans l'autre. . Opérateur (référence C#) est utilisé pour distinguer la méthode appelée.

namespace SampleNamespace
{
    class SampleClass
    {
        public void SampleMethod()
        {
            System.Console.WriteLine(
              "SampleMethod inside SampleNamespace");
        }
    }

    // Create a nested namespace, and define another class.
    namespace NestedNamespace
    {
        class SampleClass
        {
            public void SampleMethod()
            {
                System.Console.WriteLine(
                  "SampleMethod inside NestedNamespace");
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // Displays "SampleMethod inside SampleNamespace."
            SampleClass outer = new SampleClass();
            outer.SampleMethod();

            // Displays "SampleMethod inside SampleNamespace."
            SampleNamespace.SampleClass outer2 = new SampleNamespace.SampleClass();
            outer2.SampleMethod();

            // Displays "SampleMethod inside NestedNamespace."
            NestedNamespace.SampleClass inner = new NestedNamespace.SampleClass();
            inner.SampleMethod();
        }
    }
}

Noms complets

Les espaces de noms et les types ont des titres uniques décrits par des noms qualifiés complets qui indiquent une hiérarchie logique. Par exemple, l'instruction A.B implique que A est le nom de l'espace de noms ou du type, et que B est imbriqué à l'intérieur.

Dans l'exemple suivant, on trouve des classes et des espaces de noms imbriqués. Le nom qualifié complet est indiqué sous la forme d'un commentaire à la suite de chaque entité.

namespace N1     // N1
{
    class C1      // N1.C1
    {
        class C2   // N1.C1.C2
        {
        }
    }
    namespace N2  // N1.N2
    {
        class C2   // N1.N2.C2
        {
        }
    }
}

Dans le segment de code précédent :

L'espace de noms N1 est membre de l'espace de noms global. Son nom qualifié complet est N1.
L'espace de noms N2 est membre de N1. Son nom qualifié complet est N1.N2.
La classe C1 est membre de N1. Son nom qualifié complet est N1.C1.
Le nom de classe C2 est utilisé à deux reprises dans ce code. Cependant, les noms qualifiés complets sont uniques. La première instance de C2 est déclarée dans C1 ; par conséquent, son nom qualifié complet est : N1.C1.C2. La deuxième instance de C2 est déclarée dans un espace de noms N2 ; par conséquent, son nom qualifié complet est N1.N2.C2.

En utilisant le segment de code précédent, vous pouvez ajouter une nouvelle classe membre C3 à l'espace de noms N1.N2, comme suit :

namespace N1.N2
{
    class C3   // N1.N2.C3
    {
    }
}

En général, utilisez :: pour référencer un alias d'espace de noms ou global:: pour référencer l'espace de noms global et . pour qualifier des types ou des membres.

C'est une erreur d'utiliser :: avec un alias qui référence un type au lieu d'un espace de noms. Par exemple :

using Alias = System.Console;

class TestClass
{
    static void Main()
    {
        // Error
        //Alias::WriteLine("Hi");

        // OK
        Alias.WriteLine("Hi");
    }
}

N'oubliez pas que le mot global n'est pas un alias prédéfini. Par conséquent, global.X n'a pas de signification particulière. Il acquiert une signification particulière uniquement lorsqu'il est utilisé avec ::.

L'avertissement du compilateur CS0440 est généré si vous définissez un alias nommé global, car global:: référence toujours l'espace de noms global et pas un alias. Par exemple, la ligne suivante génère l'avertissement :

using global = System.Collections;   // Warning

L'utilisation de :: avec des alias est une bonne idée et protège contre l'introduction inattendue de types supplémentaires. Prenons l'exemple suivant :

using Alias = System;

namespace Library
{
    public class C : Alias.Exception { }
}

Il fonctionne, mais si un type nommé Alias est introduit par la suite, Alias. crée une liaison avec ce type à la place. L'utilisation de Alias::Exception permet de s'assurer que cet Alias est traité comme un alias d'espace de noms et non pris pour un type.

Consultez la rubrique Comment : utiliser l'alias d'espace de noms global (Guide de programmation C#) pour plus d'informations sur l'alias global.