Hvordan fungerer namespaces og using-direktiver?

Question

Accepted Answer

**Namespaces** organiserer kode i logiske grupper og forhindrer navnekollisioner (som mapper for typer). **`using`-direktiver** importerer namespaces, så du kan referere til deres typer med kort navn. Sammen strukturerer de C#-kode og giver adgang til det omfattende .NET-bibliotek. ## Erklæring af 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 { } } ``` Et namespace grupperer relaterede typer under et navn (`MyApp.Services.UserService`), hvilket forhindrer kollisioner mellem samme-navngivne klasser i forskellige namespaces. File-scoped namespaces (C# 10) reducerer indlejring. ## using-direktiver — importér 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` øverst i en fil importerer et namespace, så dets typer er tilgængelige med kort navn (i stedet for det fuldt kvalificerede navn). Du importerer de .NET-biblioteker, du har brug for, på denne måde. ## using-aliaser og 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) erklærer imports én gang for hele projektet — moderne .NET inkluderer automatisk almindelige (ImplicitUsings), så du skriver sjældent `using System;` længere. ## Bemærk: using-direktiv vs using-statement ```csharp using var file = File.OpenText("x.txt"); // using STATEMENT — auto-disposes (different feature!) ``` ## Hvorfor det betyder noget Namespaces og using-direktiver er grundlæggende for organisering af C#-kode og adgang til .NET-økosystemet, så forståelse af dem er væsentlig hverdagsviden. **Namespaces** organiserer typer i logiske grupper (afspejler mappestruktur) og forhindrer **navnekollisioner** — uden dem ville dine klasser være i konflikt med hinanden og med det omfattende .NET-bibliotek og tredjepartspakker. **`using`-direktiver** er hvordan du får adgang til det bibliotek: import af namespaces, så du kan bruge deres typer (`Console`, `List`, LINQ-metoder) med kort navn i stedet for fuldt kvalificerede navne — hver C#-fil er afhængig af usings for at få adgang til frameworkets funktionalitet. At vide, hvordan man erklærer namespaces (inkluderet moderne file-scoped-syntaks), importerer med usings, bruger aliaser til at løse konflikter, og udnytter **globale usings** (C# 10, erklæring af almindelige imports én gang for hele projektet — nu ofte auto-genereret via ImplicitUsings, så du sjældent skriver standard usings) er nødvendigt for at strukturere projekter og bruge frameworket. Forståelse af namespaces og usings — kodeorganisering, kollisionsforebyggelse, adgang til .NET-biblioteket, og de moderne globale/implicitte usings, der reducerer standard — er grundlæggende for enhver C#-udvikling, da hvert program organiserer kode i namespaces og får adgang til funktionalitet gennem usings. (Værd at skelne fra `using`-*statement*, en anden funktion til automatisk ressourcedisponering.)