Hur fungerar namespaces och using-direktiv?

Question

Accepted Answer

**Namespaces** organiserar kod i logiska grupper och förhindrar namnkollisioner (som mappar för typer). **`using`-direktiv** importerar namespaces så du kan referera till deras typer med kortare namn. tillsammans strukturerar de C#-kod och ger åtkomst till det omfattande .NET-biblioteket. ## Deklarera 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 { } } ``` Ett namespace grupperar relaterade typer under ett namn (`MyApp.Services.UserService`), vilket förhindrar kollisioner mellan lika namngivna klasser i olika namespaces. File-scoped namespaces (C# 10) minskar nästling. ## using-direktiv — importera 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 importerar ett namespace så dess typer är tillgängliga med kortare namn (istället för det fullständigt kvalificerade namnet). Du importerar de .NET-bibliotek du behöver på detta sätt. ## using-alias och globala 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) ``` **Globala usings** (C# 10) deklarerar importer en gång för hela projektet — moderna .NET inkluderar automatiskt vanliga (`ImplicitUsings`), så du skriver sällan `using System;` längre. ## Notering: using-direktiv kontra using-sats ```csharp using var file = File.OpenText("x.txt"); // using STATEMENT — auto-disposes (different feature!) ``` ## Varför det spelar roll Namespaces och using-direktiv är grundläggande för att organisera C#-kod och få åtkomst till .NET-ekosystemet, så förståelse för dem är väsentlig kunskap för daglig användning. **Namespaces** organiserar typer i logiska grupper (som speglar mappstruktur) och förhindrar **namnkollisioner** — utan dem skulle dina klasser komma i konflikt med varandra och med det omfattande .NET-biblioteket och tredjepartspaket. **`using`-direktiv** är hur du får åtkomst till det biblioteket: genom att importera namespaces så du kan använda deras typer (`Console`, `List`, LINQ-metoder) med kortare namn istället för fullständigt kvalificerade namn — varje C#-fil förlitar sig på usings för att få åtkomst till ramverkets funktionalitet. Att veta hur man deklarerar namespaces (inklusive modern file-scoped-syntax), importerar med usings, använder alias för att lösa konflikter, och utnyttjar **globala usings** (C# 10, deklarera vanliga importer en gång för hela projektet — nu ofta autogenererad via ImplicitUsings, så du skriver sällan boilerplate-usings) är nödvändigt för att strukturera projekt och använda ramverket. Förståelse för namespaces och usings — kodorganisation, kollisionsförebyggande, åtkomst till .NET-biblioteket, och moderna globala/implicita usings som minskar boilerplate — är grundläggande för all C#-utveckling, eftersom varje program organiserar kod i namespaces och får åtkomst till funktionalitet genom usings. (Värt att skilja från `using`-*satsen*, en annan funktion för automatisk resursrensning.)