C# Variablen: var, const, readonly, Gültigkeitsbereich und Benennung

Eine Variable ist ein benannter Speicherort mit einem festen Typ. In C# deklarierst du sie mit einem Typ und einem Namen und gibst ihr optional in derselben Anweisung einen Wert. Der Typ ändert sich danach nie: Eine int-Variable enthält Ganzzahlen, solange sie existiert.

using System;

class Program
{
    static void Main()
    {
        string customer = "Priya";   // declare and initialize
        int quantity;                // declare only
        quantity = 3;                // assign later
        decimal unitPrice = 4.25m;
        bool isMember = true;

        quantity = quantity + 2;     // reassign
        decimal total = quantity * unitPrice;
        if (isMember) total -= 1.00m;

        Console.WriteLine($"{customer} bought {quantity} items for {total:F2}");

        int apples = 4, pears = 6;   // several of the same type
        Console.WriteLine(apples + pears);
    }
}

Ausgabe:

Priya bought 5 items for 20.25
10

Einen Wert des falschen Typs zuzuweisen ist ein Kompilierfehler: quantity = "five"; scheitert mit CS0029 (cannot implicitly convert type 'string' to 'int'). Umwandlungen zwischen Typen sind explizit; siehe Typumwandlung.

var: den Compiler den Typ ableiten lassen

var deklariert eine lokale Variable, deren Typ aus ihrem Initialisierer abgeleitet wird. Das ist keine dynamische Typisierung: Der Typ steht zur Kompilierzeit fest, genau so, als hättest du ihn ausgeschrieben.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var name = "Oscar";          // string
        var age = 34;                // int
        var price = 19.99m;          // decimal
        var ratio = 0.75;            // double
        var tags = new List<string> { "new", "sale" };

        Console.WriteLine(name.GetType().Name);
        Console.WriteLine(age.GetType().Name);
        Console.WriteLine(price.GetType().Name);
        Console.WriteLine(ratio.GetType().Name);
        Console.WriteLine(tags.GetType().Name);

        // age = "old";  // error CS0029: age is an int, forever
    }
}

Ausgabe:

String
Int32
Decimal
Double
List`1

Für var gelten drei Regeln. Es funktioniert nur für lokale Variablen (nicht für Felder oder Parameter). Die Variable muss in der Deklaration initialisiert werden: var x; ist Fehler CS0818, „Implicitly-typed variables must be initialized“. Und der Initialisierer muss einen Typ haben: var nothing = null; kompiliert nicht, weil null allein keinen Typ hat.

Wann du es verwendest, ist eine Frage des Teamstils. Die übliche Richtlinie: var verwenden, wenn der Typ aus der rechten Seite offensichtlich ist, und den Typ ausschreiben, wenn nicht:

var orders = new List<Order>();         // obvious: var is fine
var reader = new StreamReader(path);    // obvious
decimal discount = CalculateDiscount(); // not obvious: name the type
int count = items.Count();              // makes the intent clear

Eine subtile Falle: var total = 0; macht total zu einem int, sodass späteres Addieren von 2.5 scheitert, und var price = 10; ist ein int, kein decimal. Wenn der Typ des Literals nicht der gewünschte ist, schreibe den Typ aus oder hänge ein Suffix an (10m, 0.0).

Gültigkeitsbereich

Eine lokale Variable existiert von ihrer Deklaration bis zum Ende des Blocks { }, in dem sie deklariert wurde. Variablen aus einem Schleifenkopf oder einem if-Rumpf sind danach nicht sichtbar.

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 82, 91, 67 };
        int sum = 0;                         // visible in the whole of Main

        for (int i = 0; i < scores.Length; i++)   // i: only inside the loop
        {
            int doubled = scores[i] * 2;     // doubled: only inside the loop body
            sum += scores[i];
        }
        // Console.WriteLine(i);        // error CS0103: i does not exist here

        if (sum > 200)
        {
            string label = "high";
            Console.WriteLine(label);
        }
        Console.WriteLine(sum);
    }
}

Ausgabe:

high
240

Anders als C und C++ erlaubt C# nicht, dass ein innerer Block eine lokale Variable mit demselben Namen wie eine im umgebenden Block deklariert (Fehler CS0136): Ein Name muss in der ganzen Methode dasselbe bedeuten. Zwei nebeneinanderliegende Blöcke dürfen einen Namen wiederverwenden, wie es zwei separate for-Schleifen tun, die jeweils i deklarieren.

Definitive Zuweisung

Lokale Variablen haben keinen Standardwert. Der Compiler verfolgt jeden Pfad durch die Methode und verweigert das Kompilieren, wenn eine Variable gelesen werden könnte, bevor sie zugewiesen wurde:

int discount;
if (isMember)
{
    discount = 10;
}
Console.WriteLine(discount);
// error CS0165: Use of unassigned local variable 'discount'

Behebe das, indem du bei der Deklaration initialisierst (int discount = 0;) oder in jedem Zweig zuweist (ergänze ein else). Felder und Array-Elemente sind anders: Sie werden automatisch auf den Standardwert ihres Typs gesetzt (0, false, null).

const: Konstanten zur Kompilierzeit

Ein const ist ein zur Kompilierzeit festgelegter Wert. Er muss mit einem konstanten Ausdruck initialisiert werden (einem Literal, einer anderen Konstante oder Arithmetik darauf) und kann nur eine Zahl, ein char, bool, string, Enum oder null sein.

using System;

class Pricing
{
    public const decimal VatRate = 0.20m;
    public const int MaxItems = 50;
    public const string Currency = "EUR";
    public const string Label = "Price in " + Currency; // consts can combine
}

class Program
{
    static void Main()
    {
        const int Days = 7;          // local constants work too
        decimal net = 100m;

        Console.WriteLine(Pricing.Label);
        Console.WriteLine($"{net * (1 + Pricing.VatRate):F2} {Pricing.Currency}");
        Console.WriteLine(Pricing.MaxItems * Days);
        // Pricing.MaxItems = 60;   // error: cannot assign to a constant
    }
}

Ausgabe:

Price in EUR
120.00 EUR
350

Ein const-Feld ist implizit static, der Zugriff läuft also über den Typnamen (Pricing.VatRate), und static const zu schreiben ist ein Fehler. Der Compiler kopiert den Wert an jede Stelle, die ihn verwendet. Deshalb kosten Konstanten zur Laufzeit nichts, und deshalb sollte eine öffentliche Konstante in einer Bibliothek ein Wert sein, der sich nie ändert (wie die Anzahl der Tage einer Woche).

readonly und static readonly

Ein readonly-Feld kann nur in seiner Deklaration oder in einem Konstruktor seiner Klasse zugewiesen werden. Nach der Konstruktion kann es sich nicht mehr ändern. Anders als bei const wird sein Wert zur Laufzeit berechnet, kann jeden Typ haben und sich zwischen Objekten unterscheiden.

using System;

class Account
{
    public readonly string Id;                    // set once per object
    public readonly DateTime OpenedOn;
    public static readonly DateTime Launch = new DateTime(2020, 1, 15);
    public static readonly string[] Plans = { "free", "pro" };

    public Account(string id, DateTime openedOn)
    {
        Id = id;                                  // allowed: in the constructor
        OpenedOn = openedOn;
    }

    public void Rename(string newId)
    {
        // Id = newId;  // error CS0191: readonly field outside the constructor
    }
}

class Program
{
    static void Main()
    {
        var a = new Account("ACC-17", new DateTime(2024, 5, 2));
        Console.WriteLine($"{a.Id} opened {a.OpenedOn:yyyy-MM-dd}");
        Console.WriteLine($"Launch: {Account.Launch:yyyy-MM-dd}");

        Account.Plans[0] = "basic";   // allowed: the array itself is not readonly
        Console.WriteLine(string.Join(", ", Account.Plans));
    }
}

Ausgabe:

ACC-17 opened 2024-05-02
Launch: 2020-01-15
basic, pro

Die letzten Zeilen zeigen das häufige Missverständnis: readonly schützt das Feld, nicht das Objekt, auf das es zeigt. Plans verweist immer auf dasselbe Array, aber die Elemente des Arrays können sich trotzdem ändern. Für wirklich unveränderliche Collections nimm ReadOnlyCollection<T> oder ImmutableArray<T>.

Die drei im Überblick:

Namenskonventionen

C#-Namen unterscheiden Groß- und Kleinschreibung (total und Total sind verschiedene Variablen) und müssen mit einem Buchstaben oder Unterstrich beginnen. Die Konventionen von Microsoft, an die sich fast jeder C#-Code hält:

• Lokale Variablen und Parameter: camelCase (orderCount, unitPrice).
• Konstanten, Properties, Methoden, Klassen und öffentliche Felder: PascalCase (MaxItems, VatRate).
• Private Felder: _camelCase mit führendem Unterstrich (_balance), eine in .NET-Code weit verbreitete Konvention.
• Booleans lesen sich wie Fragen: isActive, hasDiscount, canRetry.
• Vermeide Abkürzungen und ungarische Präfixe (strName, iCount).

Ein C#-Schlüsselwort kann kein Name sein, außer du stellst ein @ voran: var @class = "5B"; ist erlaubt, was gelegentlich für generierten Code oder JSON-Feldnamen nützlich ist.

Tauschen und Mehrfachzuweisung

Seit C# 7 kannst du mit Tupeln mehrere Variablen in einer Anweisung zuweisen, was einen einzeiligen Tausch ergibt:

using System;

class Program
{
    static void Main()
    {
        int first = 10, second = 20;
        (first, second) = (second, first);
        Console.WriteLine($"{first} {second}");

        var (city, population) = ("Lisbon", 545000);
        Console.WriteLine($"{city}: {population:N0}");
    }
}

Ausgabe:

20 10
Lisbon: 545,000

Die zweite Form ist Dekonstruktion: Sie deklariert aus einem Tupel city als string und population als int. Mehr unter Tupel.