Konstanten und das Schlüsselwort var

1. Konstanten

Konstante – das ist eine "magische" Variable, deren Wert man nach der Deklaration nicht (und sollte auch nicht!) ändern kann. Stell dir einen superstarken Aufkleber auf deiner Tasse mit der Aufschrift "Nur Tee" vor. Wenn du so einen Aufkleber draufmachst, kannst du den Tee nicht mehr gegen Kaffee tauschen (zumindest im Rahmen von C#).

const int DaysInWeek = 7;
const string HelloMessage = "Willkommen!";

In diesen Beispielen wird DaysInWeek immer 7 sein, und HelloMessage bleibt immer die Begrüßung. Sobald der Wert einer Konstante festgelegt ist, kann man ihn nicht mehr ändern.

Wozu braucht man Konstanten?

• Klarheit im Code: Wenn du const double Pi = 3.14159; siehst, ist sofort klar, dass das eine Konstante ist und niemand sie mitten im Programm ändern kann.
• Sicherheit: Niemand (auch du selbst nicht nach ein paar Monaten) kann den Wert der Konstante versehentlich überschreiben.
• Performance: Der C#-Compiler setzt den Wert der Konstante direkt an die Aufrufstellen ein, dadurch läuft das Programm ein bisschen schneller.

Syntax der Deklaration

const typ name = wert;

• Typ – jeder primitive Typ (int, double, string, char, sowie Enums und Literale).
• Name – üblich ist CamelCase oder PascalCase. Für "magische" Konstanten werden manchmal alle Großbuchstaben und Unterstriche verwendet (DAYS_IN_WEEK), aber in C# ist das nicht zwingend.

Beispiele:

const double GRAVITY = 9.81; // Fallbeschleunigung, m/s^2
const char DELIMITER = ',';
const string DEVELOPER_NAME = "Ivan Petrov";

Besonderheiten und Einschränkungen von Konstanten

• Der Wert muss zur Compile-Zeit bekannt sein. Das heißt, du kannst keine Konstante deklarieren, deren Wert erst zur Laufzeit berechnet wird.

const int NowYear = DateTime.Now.Year; // KOMPILIERFEHLER!

• Du kannst nur einfache Typen, string oder Enums verwenden.
• Du kannst kein Array, Objekt, das Ergebnis eines Methodenaufrufs usw. als Konstante deklarieren.
• Sogar Ausdrücke, die mathematisch "einfach" erscheinen, müssen vom Compiler berechnet werden, nicht zur Laufzeit.

So geht's zum Beispiel NICHT:

const string FullGreeting = "Hallo, " + userName; // userName ist eine Variable, so geht's nicht!

So geht's – und so sollte man es machen:

const string DefaultGreeting = "Hallo, Benutzer!";

Wo deklariert man Konstanten normalerweise?

• Am Anfang der Klasse (oder Datei), über den Methoden.
• In speziellen Klassen für Konstanten (zum Beispiel public static class Constants).
• Auf Klassenebene, wenn die Konstante nur zu dieser Klasse gehört.

Beispiel für unsere Konsolenanwendung:

class Program
{
    const string Welcome = "Willkommen in unserer Anwendung!";
    static void Main(string[] args)
    {
        Console.WriteLine(Welcome);
    }
}

Konstanten und Sichtbarkeit

Konstanten folgen denselben Sichtbarkeitsregeln wie normale Variablen: Sie sind nur im Bereich sichtbar, in dem sie deklariert wurden.

2. Das Schlüsselwort var

Das Schlüsselwort var ist kein neuer Variablentyp, sondern eine bequeme Möglichkeit, dem Compiler zu erlauben, den Typ der Variablen selbst aus dem Kontext zu bestimmen.

Das ist reiner syntaktischer Zucker – keine Magie, und nach dem Kompilieren ist die Variable vom ganz normalen Typ.

var age = 23;      // Compiler erkennt: age ist int
var name = "Anna"; // Compiler erkennt: string
var price = 99.99; // Compiler erkennt: double

Warum gibt es var?

• Lesbarkeit: Du musst keine langen Typen (wie Dictionary<string, List<int>>) von Hand schreiben.
• Flexibilität: Es ist einfacher, Typen später zu ändern: Rechts geändert – links passt sich var automatisch an.
• Moderner Stil: Fast alle modernen C#-Projekte nutzen var dort, wo der Typ aus der Initialisierung klar ist.

Wann kann (und sollte) man var verwenden

• Wenn rechts eindeutig ist, welchen Typ die Variable hat.
• Wenn der Typ offensichtlich ist (var price = 100; – klar, das ist int).
• Wenn der Typ zu lang oder kompliziert ist (z.B. das Ergebnis eines LINQ-Queries).

var numbers = new int[] { 1, 2, 3, 4 };
var input = Console.ReadLine(); // input ist string (die Methode gibt string zurück)

Wann sollte man var besser NICHT verwenden

Wenn der Typ auf der rechten Seite nicht klar ist, kann der Code unverständlich werden. Und wenn du in einem Monat selbst mit Kollegen nicht mehr weißt, was das für ein Typ war, dann gib ihn lieber explizit an.

var mystery = DoSomethingVeryComplicated(); // WER BIST DU, mystery???

Hier besser den Typ explizit angeben:

string result = DoSomethingVeryComplicated();

Goldene Regel: Verwende var nur dort, wo es die Lesbarkeit nicht verschlechtert!

var – nur für lokale Variablen

Das Schlüsselwort var funktioniert nur für lokale Variablen – also innerhalb von Methoden. Du kannst var NICHT verwenden für:

• Methodenparameter;
• Klassen-Properties;
• Konstanten.

Wie funktioniert var "unter der Haube"

• Der C#-Compiler ersetzt beim Kompilieren var durch den richtigen Typ.
• Nach dem Kompilieren gibt es kein var mehr.
• Es gibt keinen Performanceverlust: Das ist nur ein Komfort für den Entwickler.

var year = 2025; // beim Kompilieren wird daraus: int year = 2025;

Typische Fehler bei der Verwendung von var

• Nicht initialisierte Variable:

var a; // FEHLER: Der Compiler kann den Typ nicht ableiten!

• Mehrdeutige Initialisierung:

var list = null; // FEHLER: Typ null ist nicht definiert!

• Variable mit verschiedenen Typen wiederverwenden:

var value = 5; // value ist int
value = "Fünf"; // FEHLER: value ist schon int!

Vergleich: explizite Typen und var

int age = 42;

var age = 42;

Dictionary<int, string> dict = SomeFunc();

var dict = SomeFunc();

string[] names = ...

var names = ...

3. Fallen und Tipps

In C# werden oft magische Zahlen direkt in den Code geschrieben ("7", "3.14159", "0.15" und andere mysteriöse Ziffern). Das ist schlecht: Wenn sich der Wert ändert, musst du alle Vorkommen im ganzen Projekt suchen. Verwende Konstanten! Das macht es dir und deinen Kollegen leichter...

Mit var gibt es das andere Extrem: Wenn dein ganzer Code nur aus var besteht und man nirgends sieht, welche Typen verwendet werden – wird der Code schnell unverständlich. Nutze var dort, wo es logisch und aus dem Kontext klar ist, und sonst gib den Typ ruhig explizit an.