Aller au contenu principal

Namespaces et imports

Notions théoriques​

Pourquoi les namespaces ?​

Un namespace (espace de noms) organise le code en groupes logiques et évite les conflits de noms. Deux classes peuvent s'appeler Produit si elles sont dans des namespaces différents.

namespace Boutique.Inventaire
{
    class Produit { /* ... */ }
}

namespace Boutique.Ventes
{
    class Produit { /* ... */ }   // même nom, namespace différent — pas de conflit
}

Déclarer un namespace​

Syntaxe historique (accolades) :

namespace MonProjet.Modeles
{
    class Etudiant
    {
        public string Nom { get; set; } = "";
    }
}

Syntaxe file-scoped (C# 10+, recommandée) :

namespace MonProjet.Modeles;   // s'applique à tout le fichier — sans accolades

class Etudiant
{
    public string Nom { get; set; } = "";
}
File-scoped namespace — la syntaxe moderne

La syntaxe file-scoped (namespace MonProjet; sans accolades) est disponible depuis C# 10. Elle évite un niveau d'indentation pour tout le fichier. Les nouveaux projets utilisent systématiquement cette syntaxe.

using — importer un namespace​

using permet d'utiliser les types d'un namespace sans écrire le chemin complet à chaque fois :

// Sans using : chemin complet obligatoire
System.Console.WriteLine("Bonjour");
System.Collections.Generic.List<string> liste = new System.Collections.Generic.List<string>();

// Avec using : nom court suffit
using System;
using System.Collections.Generic;

Console.WriteLine("Bonjour");
List<string> liste = new List<string>();

Namespaces courants de .NET​

NamespaceContenu
SystemTypes de base : Console, Math, Environment, DateTime...
System.Collections.GenericList<T>, Dictionary<K,V>, HashSet<T>...
System.IOFile, Directory, StreamReader, StreamWriter...
System.LinqMéthodes LINQ : .Where(), .Select(), .OrderBy()...
System.TextStringBuilder, Encoding...
System.Net.HttpHttpClient pour les appels HTTP

ImplicitUsings — imports automatiques​

Dans les projets .NET 6+, le .csproj contient <ImplicitUsings>enable</ImplicitUsings>. Cela active automatiquement les imports les plus courants — vous n'avez pas à les écrire dans chaque fichier :

<!-- Dans le .csproj -->
<ImplicitUsings>enable</ImplicitUsings>

Les namespaces suivants sont importés automatiquement pour les applications console :

  • System
  • System.Collections.Generic
  • System.IO
  • System.Linq
  • System.Threading.Tasks
  • System.Text

global using — imports globaux (C# 10+)​

global using importe un namespace dans tous les fichiers du projet :

// Fichier GlobalUsings.cs (par convention)
global using System.Text.Json;
global using MonProjet.Modeles;
global using MonProjet.Services;

Alias pour éviter les conflits​

Si deux namespaces contiennent une classe de même nom, utilisez un alias :

using BoutiqueModele = Boutique.Inventaire.Produit;
using VentesModele   = Boutique.Ventes.Produit;

var produitStock = new BoutiqueModele();
var produitVente = new VentesModele();

Convention de nommage des namespaces​

La convention officielle Microsoft est NomEntreprise.NomProduit.Fonctionnalite :

MonEntreprise.MonApplication.Modeles
MonEntreprise.MonApplication.Services
MonEntreprise.MonApplication.Utilitaires

En BTS SIO, on simplifie souvent : NomProjet.Modeles, NomProjet.Services.

Exemple pratique​

// Fichier : Modeles/Etudiant.cs
namespace GestionScolaire.Modeles;

class Etudiant
{
    public string Nom  { get; set; } = "";
    public double Note { get; set; }

    public override string ToString() => $"{Nom} ({Note:F1}/20)";
}

// Fichier : Services/BulletinService.cs
namespace GestionScolaire.Services;

using GestionScolaire.Modeles;

class BulletinService
{
    public static string Generer(Etudiant e)
    {
        string mention = e.Note switch
        {
            >= 16 => "Très bien",
            >= 10 => "Passable",
            _     => "Insuffisant",
        };
        return $"Bulletin : {e} — {mention}";
    }
}

// Fichier : Program.cs (top-level, pas de namespace)
using GestionScolaire.Modeles;
using GestionScolaire.Services;

var alice = new Etudiant { Nom = "Alice", Note = 15.5 };
Console.WriteLine(BulletinService.Generer(alice));

Test de mémorisation/compréhension​


Quel est le rôle principal des namespaces ?


Quelle est la syntaxe file-scoped pour un namespace (C# 10+) ?


Que fait `<ImplicitUsings>enable</ImplicitUsings>` dans le `.csproj` ?


Comment importer un namespace dans TOUS les fichiers du projet avec C# 10+ ?


Quel namespace contient les types LINQ comme `.Where()` et `.Select()` ?


TP pour réfléchir et résoudre des problèmes​

Vous allez organiser un projet multi-fichiers avec des namespaces.

Étape 1 — Structurer le projet​

Dans un vrai projet, chaque classe est dans son propre fichier. Ici, on simule la structure avec des namespaces explicites dans un seul fichier.


Bonne pratique - Un fichier par classe, namespace aligné sur le dossier

La convention est : une classe par fichier, et le namespace correspond au chemin du dossier depuis la racine du projet. Modeles/Produit.cs → namespace GestionStock.Modeles;. Cela rend la navigation dans le code intuitive et est supporté par tous les IDE .NET.

Étape 2 — Importer et utiliser les namespaces​

Importez le namespace du modèle dans le service.


Bonne pratique - Importer uniquement les namespaces nécessaires

N'importez que les namespaces dont vous avez réellement besoin dans chaque fichier. Des imports inutiles encombrent le code et peuvent créer des ambiguïtés si deux namespaces contiennent des types de même nom. Les IDE modernes signalent les imports inutilisés.

Étape 3 — Utiliser les services dans Program.cs​

Assemblez les pièces en important les deux namespaces.


Bonne pratique - Program.cs sans namespace

Par convention, Program.cs (le point d'entrée) n'a pas de namespace. Il importe les namespaces nécessaires et orchestre l'application. Cette séparation — Program.cs comme chef d'orchestre, les autres fichiers comme musiciens — est un pattern classique en .NET.

📌 Une solution