Hoe werken namespaces en using-richtlijnen?

Question

Accepted Answer

**Namespaces** organiseren code in logische groepen en voorkomen naamconflicten (zoals mappen voor typen). **`using`-richtlijnen** importeren namespaces zodat je hun typen bij korte naam kunt aanroepen. Samen structureren ze C#-code en geven ze toegang tot de uitgebreide .NET-bibliotheek. ## Namespaces declareren ```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 { } } ``` Een namespace groepeert gerelateerde typen onder een naam (`MyApp.Services.UserService`), waardoor botsingen tussen gelijknamige klassen in verschillende namespaces worden voorkomen. File-scoped namespaces (C# 10) verminderen nesting. ## using-richtlijnen — namespaces importeren ```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` bovenaan een bestand importeert een namespace zodat de typen beschikbaar zijn bij korte naam (in plaats van de volledig gekwalificeerde naam). Op deze manier importeer je de .NET-bibliotheken die je nodig hebt. ## using-aliassen en globale usings ```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) ``` **Globale usings** (C# 10) declareren imports eenmaal voor het hele project — moderne .NET voegt veel voorkomende automatisch in (`ImplicitUsings`), dus je hoeft zelden `using System;` meer te schrijven. ## Opmerking: using-richtlijn vs using-statement ```csharp using var file = File.OpenText("x.txt"); // using STATEMENT — auto-disposes (different feature!) ``` ## Waarom het belangrijk is Namespaces en using-richtlijnen zijn fundamenteel voor het organiseren van C#-code en toegang tot het .NET-ecosysteem, dus het begrijpen ervan is essentiële dagelijkse kennis. **Namespaces** organiseren typen in logische groepen (die de mappenstructuur weerspiegelen) en voorkomen **naamconflicten** — zonder ze zouden je klassen met elkaar en met de uitgebreide .NET-bibliotheek en derde-pakketten in botsing komen. **`using`-richtlijnen** zijn hoe je toegang krijgt tot die bibliotheek: namespaces importeren zodat je hun typen (`Console`, `List`, LINQ-methoden) bij korte naam in plaats van volledig gekwalificeerde namen kunt gebruiken — elk C#-bestand is afhankelijk van usings om toegang te krijgen tot de functionaliteit van het framework. Weten hoe je namespaces declareert (inclusief moderne file-scoped-syntax), importeert met usings, aliassen gebruikt om conflicten op te lossen, en **globale usings** leverageert (C# 10, waarbij veel voorkomende imports eenmaal voor het hele project worden gedeclareerd — nu vaak automatisch gegenereerd via ImplicitUsings, dus je hoeft zelden boilerplate usings te schrijven) is noodzakelijk voor het structureren van projecten en het gebruik van het framework. Het begrijpen van namespaces en usings — code-organisatie, conflictpreventie, toegang tot de .NET-bibliotheek, en de moderne globale/impliciete usings die boilerplate verminderen — is fundamenteel voor C#-ontwikkeling, omdat elk programma code in namespaces organiseert en functionaliteit via usings opent. (Het is de moeite waard om dit te onderscheiden van de `using`-*statement*, een ander onderdeel voor automatische resourcebeschikking.)