Partager via

Espaces de noms et directives d’utilisation

Conseil / Astuce

Vous débutez avec le développement de logiciels ? Commencez par commencer par les didacticiels De prise en main . Ils introduisent des espaces de noms et des directives using lorsque vous écrivez vos premiers programmes.

Maîtrisez-vous une autre langue ? Les espaces de noms en C# fonctionnent de la même façon que les packages en Java ou les modules en Python. Parcourez la syntaxe dont vous avez besoin.

Les déclarations d’espace de noms et les directives using sont des fonctionnalités linguistiques associées. Une déclaration d’espace de noms place vos types dans une structure organisée. Un espace de noms regroupe les types associés et empêche les collisions d’affectation de noms. Une using directive permet à votre programme d’utiliser ces types par leurs noms simples. Vous n’avez pas besoin d’expliquer le chemin d’accès complet de l’espace de noms à chaque utilisation.

Vous avez déjà utilisé des espaces de noms dans chaque programme C# que vous avez écrit. Chaque type .NET appartient à un espace de noms, et chaque using directive en haut d’un fichier fait référence à un. Par exemple, Console et Math appartiennent à l’espace System de noms, de sorte que leurs noms complets sont System.Console et System.Math. Les types de collection comme List<T> et Dictionary<TKey, TValue> appartiennent à System.Collections.Generic. Une directive unique using pour l’un de ces espaces de noms vous permet de faire référence à tous ses types par leurs noms simples. Vous écrivez List<T> au lieu de System.Collections.Generic.List<T> partout où vous l’utilisez.

Cet article fournit plus d’informations sur le fonctionnement des espaces de noms et using des directives, et présente des exemples de modèles que vous avez déjà rencontrés dans les bibliothèques .NET.

Un espace de noms contient des types. Chaque type .NET appartient à un espace de noms. Par exemple, considérez System.Threading.Tasks.Task: le type Task appartient à l’espace System.Threading.Tasks de noms.

Il est recommandé de regrouper des types connexes ou similaires dans le même espace de noms, et c’est ce que fait .NET avec les types qu’il fournit. L’espace de noms System.Collections.Generic contient des types liés aux collections et l’espace de noms System.IO contient des types associés à la lecture et à l’écriture de fichiers, de répertoires et de données. L’espace System de noms contient des types fondamentaux tels que Math, DateTimeet Console.

L’exemple suivant montre comment les espaces de noms fonctionnent avec using directives dans un fichier C# typique.

using System.Globalization;

namespace MyApp.Services;

class Greeter
{
    public string Greet(string name)
    {
        var culture = CultureInfo.CurrentCulture;
        return $"Hello, {name}! Culture: {culture.Name}";
    }
}

Dans l’exemple précédent, la directive using signifie que vous pouvez utiliser System.Globalization.CultureInfo par le nom CultureInfo sans spécifier le nom complet de l’élément System.Globalization.CultureInfo. La namespace directive déclare que la Greeter classe fait partie de l’espace MyApp.Services de noms. Son nom entièrement qualifié est MyApp.Services.Greeter.

Déclarations d’espace de noms

Une déclaration d’espace de noms affecte vos types à un groupe nommé. Chaque type que vous écrivez doit appartenir à un espace de noms. Le nom de l’espace de noms reflète généralement la structure de dossiers de votre projet. Par exemple, les types dans un dossier Services/Payments appartiennent souvent à l'espace de noms MyApp.Services.Payments.

Les espaces de noms utilisent l’opérateur . pour exprimer la hiérarchie, par exemple System.Collections.Generic. Les noms d’espaces de noms doivent être des noms d’identificateur C# valides.

Espaces de noms limités aux fichiers

Utilisez la syntaxe spécifiée au niveau du fichier lorsque tous les types d’un fichier appartiennent au même espace de noms. Ajoutez un point-virgule après la déclaration d’espace de noms, et cela s’applique à l’intégralité du fichier. Vous n’avez pas besoin d’accolades ou d’indentation supplémentaires :

namespace MyApp.Models;

class Customer
{
    public required string Name { get; init; }
    public string? Email { get; init; }

    public override string ToString() => $"{Name} ({Email ?? "no email"})";
}

Les espaces de noms limités aux fichiers réduisent l'enchevêtrement et facilitent la lecture des fichiers. Vous ne pouvez avoir qu’une seule déclaration d’espace de noms délimitée par fichier.

Conseil / Astuce

Utilisez des espaces de noms délimités par des fichiers dans le nouveau code. La plupart des modèles et analyseurs de code .NET recommandent ce style.

Espaces de noms délimités par des blocs

Utilisez la syntaxe à étendue de bloc lorsque vous devez déclarer plusieurs espaces de noms dans le même fichier. Ce style ajoute un niveau supplémentaire de retrait.

Important

Il est considéré comme incorrect de déclarer plusieurs espaces de noms dans le même fichier. Le scénario le plus courant consiste à utiliser des espaces de noms délimités aux fichiers.

L’extrait de code suivant est un exemple d’espace de noms délimité par un bloc :

namespace MyApp.Models
{
    class Product
    {
        public required string Name { get; init; }
        public decimal Price { get; init; }

        public override string ToString() => $"{Name}: {Price:C}";
    }
}

Utilisation de directives

using Sans directive, vous devez faire référence à chaque type par son nom complet, le chemin complet de l’espace de noms ainsi que le nom de type :

static void ShowFullyQualified()
{
    // Without a using directive, use the fully qualified name:
    System.Console.WriteLine("Hello from fully qualified name!");
}

Une using directive en haut d’un fichier importe un espace de noms afin de pouvoir utiliser ses types par leurs noms simples :

static void ShowShortName()
{
    // With 'using System;' (or implicit usings enabled), use the short name:
    Console.WriteLine("Hello from short name!");
}

Pour plus d’informations, consultez la using directive.

Directives d’utilisation globale

Si vous écrivez les mêmes using directives dans chaque fichier, l’utilisation globale des directives vous permet de les déclarer une fois pour l’ensemble de votre projet. Placez-les dans n’importe quel fichier. De nombreuses équipes créent un fichier dédié GlobalUsings.cs :

global using System.Text;
global using System.Text.Json;

Après avoir déclaré une utilisation globale, chaque fichier du projet peut faire référence aux types de cet espace de noms en utilisant des noms simples sans directive supplémentaire using .

Utilisations implicites

Le SDK .NET génère automatiquement des directives using globales pour les espaces de noms les plus courants selon votre type de projet. Activez les utilisations implicites en définissant <ImplicitUsings>enable</ImplicitUsings> dans votre fichier projet. Par exemple, un projet d'application console importe automatiquement System, System.Collections.Generic, System.IO, System.Linq, System.Threading et System.Threading.Tasks. Le ImplicitUsings est activé dans la version actuelle du SDK lorsque vous créez un nouveau projet à l’aide de dotnet new.

Pour plus d’informations, consultez Directives d’utilisation implicite.

Directives d’utilisation statique

Une static using directive importe les membres statiques d’un type afin de pouvoir les appeler sans préfixe de nom de type :

using static System.Math;

namespace MyApp.Utilities;

class CircleCalculator
{
    public static double CalculateArea(double radius) => PI * Pow(radius, 2);

    public static double CalculateCircumference(double radius) => 2 * PI * radius;
}

Les utilisations statiques fonctionnent bien pour les classes utilitaires comme Math et Console que vous appelez fréquemment.

Alias de type et d’espace de nommage

Un using alias crée un nom abrégé pour un type ou un espace de noms. Les alias sont utiles pour les types génériques longs, la résolution des conflits d’affectation de noms et l’amélioration de la lisibilité :

using CustomerList = System.Collections.Generic.List<MyApp.Models.Customer>;

namespace MyApp.Services;

class CustomerService
{
    public CustomerList GetTopCustomers()
    {
        CustomerList customers = [new() { Name = "Alice" }, new() { Name = "Bob" }];
        return customers;
    }
}

À compter de C# 12, vous pouvez créer un alias pour n’importe quel type, y compris les tuples et les types pointeur :

using Point = (double X, double Y);

namespace MyApp.Geometry;

class Shape
{
    public static double Distance(Point a, Point b)
    {
        var dx = a.X - b.X;
        var dy = a.Y - b.Y;
        return Math.Sqrt(dx * dx + dy * dy);
    }
}

Pour les scénarios plus avancés où deux assemblys définissent le même nom de type complet, utilisez l’alias extern pour lever l’ambiguïté entre eux.

Contenu connexe

  • Last updated on