Comment fonctionnent les namespaces et les directives using ?

Question

Accepted Answer

**Namespaces** organisent le code en groupes logiques et préviennent les collisions de noms (comme des dossiers pour les types). **Les directives `using`** importent les namespaces afin que vous puissiez faire référence à leurs types par un nom court. Ensemble, ils structurent le code C# et permettent d'accéder à la vaste bibliothèque .NET. ## Déclarer les namespaces ```csharp // declare a namespace (conventionally matching the folder structure) namespace MyApp.Services; // file-scoped namespace (C# 10) — applies to the whole file public class UserService { } // fully-qualified name: MyApp.Services.UserService // or block-scoped (traditional) namespace MyApp.Models { public class User { } } ``` Un namespace groupe les types connexes sous un nom (`MyApp.Services.UserService`), prévenant les collisions entre des classes portant le même nom dans des namespaces différents. Les namespaces limités au fichier (C# 10) réduisent l'imbrication. ## Directives using — importer les namespaces ```csharp using System; // import → use Console instead of System.Console using System.Collections.Generic; // → List, Dictionary using System.Linq; // → LINQ extension methods using MyApp.Services; // your own namespaces Console.WriteLine("hi"); // short name works thanks to `using System;` var list = new List(); // thanks to the Generic using ``` `using` au début d'un fichier importe un namespace afin que ses types soient disponibles par un nom court (au lieu du nom complètement qualifié). Vous importez les bibliothèques .NET dont vous avez besoin de cette façon. ## Alias using et usings globaux ```csharp using Project = MyApp.Models.Project; // ALIAS — resolve a name conflict or shorten // GLOBAL using (C# 10) — apply to the ENTIRE project, declared once global using System; global using System.Collections.Generic; // → no need to repeat common usings in every file (often auto-generated) ``` **Les usings globaux** (C# 10) déclarent les imports une seule fois pour tout le projet — .NET moderne inclut automatiquement les usings courants (`ImplicitUsings`), donc vous n'écrivez presque jamais `using System;` de nos jours. ## Remarque : directive using vs instruction using ```csharp using var file = File.OpenText("x.txt"); // using STATEMENT — auto-disposes (different feature!) ``` ## Pourquoi c'est important Les namespaces et les directives using sont fondamentaux pour organiser le code C# et accéder à l'écosystème .NET, donc les comprendre est une connaissance essentielle du quotidien. **Les namespaces** organisent les types en groupes logiques (reflétant la structure des dossiers) et préviennent les **collisions de noms** — sans eux, vos classes entreraient en conflit les unes avec les autres et avec la vaste bibliothèque .NET et les packages tiers. **Les directives `using`** vous permettent d'accéder à cette bibliothèque : importer les namespaces afin que vous puissiez utiliser leurs types (`Console`, `List`, les méthodes LINQ) par nom court plutôt que par des noms complètement qualifiés — chaque fichier C# s'appuie sur les usings pour accéder aux fonctionnalités de la framework. Savoir comment déclarer les namespaces (y compris la syntaxe moderne limités au fichier), importer avec les usings, utiliser des alias pour résoudre les conflits et exploiter **les usings globaux** (C# 10, déclarant les imports courants une seule fois pour tout le projet — souvent générés automatiquement via ImplicitUsings, donc vous écrivez rarement des usings standardisés) est nécessaire pour structurer les projets et utiliser la framework. Comprendre les namespaces et les usings — organisation du code, prévention des collisions, accès à la bibliothèque .NET, et les usings globaux/implicites modernes qui réduisent les boilerplate — est fondamental pour tout développement C#, car chaque programme organise le code dans des namespaces et accède aux fonctionnalités via les usings. (Il est utile de distinguer l'*instruction* `using`, une fonctionnalité différente pour l'élimination automatique des ressources.)