Hvordan erklærer du variabler og bruger var?

Question

Accepted Answer

C# er statisk typet — variabler har en type kendt på kompileringstidspunktet. Du kan erklære en variabel med en eksplicit type eller bruge **`var`** til typeudledelse (compileren udleder typen fra værdien), men uanset hvad er typen fastsat. ## Erklæring af variabler ```csharp int count = 42; // explicit type string name = "Ann"; double price = 9.99; bool active = true; var age = 30; // inferred as int (var = let the compiler figure it out) var message = "Hello"; // inferred as string var items = new List(); // inferred as List ``` `var` udleder typen fra initializeren — `var age = 30` er præcis det samme som `int age = 30`. Afgørende er, at **`var` stadig er statisk typet**: typen fastsat på kompileringstidspunktet (du kan ikke senere tildele en string til `age`); den er blot udledt, ikke dynamisk. ## var kræver en initializer og holder typen fastsat ```csharp var x = 5; x = "hi"; // ❌ compile error — x is an int, can't become a string var y; // ❌ error — var needs an initializer to infer from ``` ## Hvornår skal man bruge var (stilkonvention) ```csharp var user = new UserService(); // ✅ type is obvious from the right side — var is clean var count = users.Count; int total = CalculateComplexValue(); // explicit when the type isn't obvious aids readability ``` Brug `var` når typen er åbenbar fra højresiden (reducerer redundans, især med lange generiske typer); brug eksplicitte typer når det forbedrer klarhed. ## Konstanter og andre erklæringer ```csharp const double Pi = 3.14159; // compile-time constant (can't change) readonly int id; // set once (in constructor), then immutable int a = 1, b = 2; // multiple of the same type nint nativeInt; // platform-sized integer ``` ## Almindelige indbyggede typer ```text int, long, short, byte integers float, double, decimal floating point (decimal for money — exact) bool, char, string boolean, character, text object the base of all types ``` ## Hvorfor det betyder noget At forstå variabeldeklaration og `var` er grundlæggende, daglig C#-viden. Hovedkonceptet er, at **`var` er typeudledelse, ikke dynamisk typing** — en almindelig misforståelse. Med `var` udleder compileren typen fra initializeren, men typen er stadig fastsat på kompileringstidspunktet (du får alle fordelene ved statisk typing — typetjek, IntelliSense, ydeevne), blot uden at skrive typenavnet eksplicit. Dette gør `var` til en bekvemmelighed for læsbarhed (især med omfattende generiske typer som `Dictionary>`) snarere end en løsning af typesystemet. At vide hvornår man skal bruge `var` (når typen er åbenbar fra højresiden, hvilket reducerer redundans) versus eksplicitte typer (når det forbedrer klarhed), sammen med de indbyggede typer (især **`decimal` til penge** — nøjagtig decimalregning, i modsætning til `double`), konstanter (`const`, `readonly`), er dagligdags viden for at skrive C#. At forstå, at C# er statisk typet hele vejen igennem (uanset om du skriver typen eller bruger `var`), og idiomerne omkring variabeldeklaration, er fundamentalt for at læse og skrive rent, korrekt C#-kode, og pointen om at `var` ikke er dynamisk er en hyppig præcisering, der afspejler korrekt forståelse af sproget.