Wie deklarierst du Variablen und verwendest var?

Question

Accepted Answer

C# ist statisch typisiert — Variablen haben einen zur Compile-Zeit bekannten Typ. Du kannst eine Variable mit einem expliziten Typ deklarieren oder **`var`** für Typinferenz verwenden (der Compiler leitet den Typ aus dem Wert ab), aber in beiden Fällen ist der Typ fest. ## Variablen deklarieren ```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` leitet den Typ vom Initialisierer ab — `var age = 30` ist exakt dasselbe wie `int age = 30`. Entscheidend ist: **`var` ist immer noch statisch typisiert**: Der Typ wird zur Compile-Zeit festgelegt (du kannst später keinen String zu `age` zuweisen); er wird nur hergeleitet, nicht dynamisch bestimmt. ## var erfordert einen Initialisierer und behält den Typ bei ```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 ``` ## Wann var verwendet werden sollte (Stil) ```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 ``` Verwende `var`, wenn der Typ von der rechten Seite offensichtlich ist (reduziert Redundanz, besonders bei langen generischen Typen); verwende explizite Typen, wenn dies die Klarheit verbessert. ## Konstanten und andere Deklarationen ```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 ``` ## Häufige Built-in-Typen ```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 ``` ## Warum es wichtig ist Das Verstehen von Variablendeklaration und `var` ist fundamentales Alltagswissen in C#. Der Schlüsselpunkt ist: **`var` ist Typinferenz, nicht dynamische Typisierung** — ein häufiges Missverständnis. Mit `var` leitet der Compiler den Typ vom Initialisierer her, aber der Typ ist immer noch zur Compile-Zeit festgelegt (du erhältst alle Vorteile der statischen Typisierung — Typprüfung, IntelliSense, Leistung), nur ohne dass du den Typnamen explizit schreibst. Dies macht `var` zu einer Annehmlichkeit für die Lesbarkeit (besonders bei ausführlichen generischen Typen wie `Dictionary>`) statt einer Lockerung des Typsystems. Zu wissen, wann man `var` verwendet (wenn der Typ von der rechten Seite offensichtlich ist und Redundanz reduziert) versus explizite Typen (wenn dies die Klarheit verbessert), sowie die Built-in-Typen (besonders **`decimal` für Geldwerte** — exakte Dezimalarithmetik, anders als `double`), Konstanten (`const`, `readonly`), ist Alltagswissen beim Schreiben von C#. Zu verstehen, dass C# durchgehend statisch typisiert ist (egal ob du den Typ schreibst oder `var` verwendest), und die Idiome rund um Variablendeklaration, ist grundlegend für das Lesen und Schreiben von sauberem, korrektem C#-Code, und die Klarstellung, dass `var` nicht dynamisch ist, ist eine häufige Präzisierung, die ein korrektes Verständnis der Sprache widerspiegelt.