C# Variablen & Primitive Datentypen meistern: Der komplette Guide

C# Variablen und (Primitive) Datentypen

In diesem Tutorial lernen wir Variablen kennen, wie man Variablen in C# erstellt und welche Datentypen die C#-Programmiersprache unterstützt.

Eine Variable ist ein symbolischer Name für eine Speicheradresse. Variablen werden genutzt, um Daten in einem Computerprogramm zu speichern.

---

Wie deklariert man Variablen in C#?

Hier ist ein Beispiel zur Deklaration einer Variable in C#.

int age;

In diesem Beispiel wird eine Variable age vom Typ int (Integer) deklariert, die nur Integerwerte speichern kann.

Wir können der Variable später im Programm einen Wert zuweisen:

int age;
...
...
...
age = 24;

Die Variable kann jedoch auch bei der Deklaration initialisiert werden. Zum Beispiel:

int age = 24;

Hier wird eine Variable age vom Typ int deklariert und gleichzeitig auf 24 initialisiert.

Da es eine Variable ist, können wir den Wert auch ändern. Zum Beispiel:

int age = 24;
age = 35;

Hier wird der Wert von age von 24 auf 35 geändert.

---

Variablen in C# müssen deklariert werden, bevor sie verwendet werden können. Das bedeutet, Name und Typ der Variable müssen bekannt sein, bevor ein Wert zugewiesen werden kann. Deshalb nennt man C# eine statisch typisierte Sprache.

Einmal deklariert, kann der Datentyp einer Variable innerhalb eines Scopes nicht geändert werden. Ein Scope kann als Codeblock betrachtet werden, in dem die Variable sichtbar oder verfügbar ist. Falls Sie die vorherige Aussage nicht verstehen, keine Sorge – wir lernen Scopes in späteren Kapiteln.

Merken Sie sich für jetzt: Folgendes ist in C# nicht möglich:

int age;
age = 24;
...
...
...
float age;

---

Implizit typisierte Variablen

Alternativ können wir in C# eine Variable deklarieren, ohne ihren Typ zu kennen, mittels var-Keyword. Solche Variablen heißen implizit typisierte lokale Variablen.

Mit var deklarierte Variablen müssen zum Deklarationszeitpunkt initialisiert werden.

var value = 5;

Der Compiler bestimmt den Variablentyp aus dem zugewiesenen Wert. Im obigen Beispiel ist value vom Typ int. Dies ist äquivalent zu:

int value;
value = 5;

Mehr zu implizit typisierten lokalen Variablen erfahren Sie hier.

---

Regeln für das Benennen von Variablen in C#

Es gibt bestimmte Regeln für Variablennamen. Die Regeln für das Benennen einer Variable in C# sind:

1. Der Variablenname darf nur Buchstaben (Groß- und Kleinbuchstaben), Unterstriche (_) und Ziffern enthalten.
2. Der Variablenname muss mit einem Buchstaben, Unterstrich oder @-Symbol beginnen. Zum Beispiel:

   Regeln für das Benennen von Variablen in C#

   Variablennamen	Bemerkungen
   name	Gültig
   subject101	Gültig
   _age	Gültig (Best Practice für private Membervariablen)
   @break	Gültig (wenn Name ein reserviertes Keyword ist)
   101subject	Ungültig (beginnt mit Ziffer)
   your_name	Gültig
   your name	Ungültig (enthält Whitespace)

3. C# ist case-sensitive. Das bedeutet age und Age beziehen sich auf 2 verschiedene Variablen.
4. Ein Variablenname darf kein C#-Keyword sein. Zum Beispiel können if, for, using keine Variablennamen sein. Wir werden mehr über C#-Keywords im nächsten Tutorial besprechen.

---

Best Practices für das Benennen einer Variable

1. Wählen Sie einen Variablennamen, der Sinn ergibt. Zum Beispiel name, age, subject machen mehr Sinn als n, a und s.
2. Nutzen Sie camelCase-Notation (beginnt mit Kleinbuchstabe) für lokale Variablen. Zum Beispiel numberOfStudents, age, etc.
3. Nutzen Sie PascalCase oder CamelCase (beginnt mit Großbuchstabe) für öffentliche Membervariablen. Zum Beispiel FirstName, Price, etc.
4. Nutzen Sie einen führenden Unterstrich (_) gefolgt von camelCase für private Membervariablen. Zum Beispiel _bankBalance, _emailAddress, etc.

Mehr zu Namenskonventionen in C# hier.

Keine Sorge um public und private Membervariablen. Wir lernen sie in späteren Kapiteln.

---

C# Primitive Datentypen

Variablen in C# werden breit in zwei Typen klassifiziert: Werttypen und Referenztypen. In diesem Tutorial besprechen wir primitive (einfache) Datentypen, eine Unterklasse der Werttypen.

Referenztypen werden in späteren Tutorials behandelt. Falls Sie mehr über Variablentypen wissen wollen, besuchen Sie C# Types and variables (offizielle C#-Dokumentation).

Boolean (bool)

• Boolean-Datentyp hat zwei mögliche Werte: true oder false
• Standardwert: false
• Boolean-Variablen werden allgemein für Bedingungsprüfungen genutzt, z. B. in if-Statements, Schleifen, etc.

Beispiel:

using System;
namespace DataType
{
    class BooleanExample
    {
        public static void Main(string[] args)
        {
            bool isValid = true;
            Console.WriteLine(isValid);
        }
    }
}

Programmoutput:

True

---

Vorzeichenbehaftete Ganzzahlen (Signed Integral)

Diese Datentypen halten Integerwerte (sowohl positiv als auch negativ). Von den gesamten verfügbaren Bits wird ein Bit für das Vorzeichen genutzt.

1. sbyte

• Größe: 8 Bit
• Bereich: -128 bis 127.
• Standardwert: 0

Beispiel:

using System;
namespace DataType
{
    class SByteExample
    {
        public static void Main(string[] args)
        {
            sbyte level = 23;
            Console.WriteLine(level);
        }
    }
}

Output: 23

Versuchen Sie, Werte außerhalb des Bereichs zuzuweisen (kleiner -128 oder größer 127) und beobachten Sie das Ergebnis.

---

2. short

• Größe: 16 Bit
• Bereich: -32.768 bis 32.767
• Standardwert: 0

Beispiel:

using System;
namespace DataType
{
    class ShortExample
    {
        public static void Main(string[] args)
        {
            short value = -1109;
            Console.WriteLine(value);
        }
    }
}

Output: -1109

---

3. int

• Größe: 32 Bit
• Bereich: -2³¹ bis 2³¹-1
• Standardwert: 0

Beispiel:

using System;
namespace DataType
{
    class IntExample
    {
        public static void Main(string[] args)
        {
            int score = 51092;
            Console.WriteLine(score);
        }
    }
}

Output: 51092

---

4. long

• Größe: 64 Bit
• Bereich: -2⁶³ bis 2⁶³-1
• Standardwert: 0L [L am Ende kennzeichnet long-Typ]

Beispiel:

using System;
namespace DataType
{
    class LongExample
    {
        public static void Main(string[] args)
        {
            long range = -7091821871L;
            Console.WriteLine(range);
        }
    }
}

Output: -7091821871

---

Vorzeichenlose Ganzzahlen (Unsigned Integral)

Diese Datentypen halten nur Werte ≥ 0. Wir nutzen sie generell, wenn wir sicher sind, keine negativen Werte zu haben.

1. byte

• Größe: 8 Bit
• Bereich: 0 bis 255.
• Standardwert: 0

Beispiel:

using System;
namespace DataType
{
    class ByteExample
    {
        public static void Main(string[] args)
        {
            byte age = 62;
            Console.WriteLine(age);
        }
    }
}

Output: 62

---

2. ushort

• Größe: 16 Bit
• Bereich: 0 bis 65.535
• Standardwert: 0

Beispiel:

using System;
namespace DataType
{
    class UShortExample
    {
        public static void Main(string[] args)
        {
            ushort value = 42019;
            Console.WriteLine(value);
        }
    }
}

Output: 42019

---

3. uint

• Größe: 32 Bit
• Bereich: 0 bis 2³²-1
• Standardwert: 0

Beispiel:

using System;
namespace DataType
{
    class UIntExample
    {
        public static void Main(string[] args)
        {
            uint totalScore = 1151092;
            Console.WriteLine(totalScore);
        }
    }
}

Output: 1151092

---

4. ulong

• Größe: 64 Bit
• Bereich: 0 bis 2⁶⁴-1
• Standardwert: 0

Beispiel:

using System;
namespace DataType
{
    class ULongExample
    {
        public static void Main(string[] args)
        {
            ulong range = 17091821871L;
            Console.WriteLine(range);
        }
    }
}

Output: 17091821871

---

Gleitkommazahlen (Floating Point)

Diese Datentypen halten Gleitkommawerte, also Zahlen mit Dezimalstellen. Zum Beispiel 12,36, -92,17, etc.

1. float

• Single-Precision-Gleitkommatyp
• Größe: 32 Bit
• Bereich: 1,5 × 10⁻⁴⁵ bis 3,4 × 10³⁸
• Standardwert: 0,0F [F am Ende kennzeichnet float-Typ]

Beispiel:

using System;
namespace DataType
{
    class FloatExample
    {
        public static void Main(string[] args)
        {
            float number = 43.27F;
            Console.WriteLine(number);
        }
    }
}

Output: 43.27

---

2. double

• Double-Precision-Gleitkommatyp. Was ist der Unterschied zwischen Single- und Double-Precision?
• Größe: 64 Bit
• Bereich: 5,0 × 10⁻³²⁴ bis 1,7 × 10³⁰⁸
• Standardwert: 0,0D [D am Ende kennzeichnet double-Typ]

Beispiel:

using System;
namespace DataType
{
    class DoubleExample
    {
        public static void Main(string[] args)
        {
            double value = -11092.53D;
            Console.WriteLine(value);
        }
    }
}

Output: -11092.53

---

Zeichen (char)

• Stellt ein 16-Bit-Unicode-Zeichen dar.
• Größe: 16 Bit
• Standardwert: '\0'
• Bereich: U+0000 ('\u0000') bis U+FFFF ('\uffff')

Beispiel:

using System;
namespace DataType
{
    class CharExample
    {
        public static void Main(string[] args)
        {
            char ch1 = '\u0042';
            char ch2 = 'x';
            Console.WriteLine(ch1);
            Console.WriteLine(ch2);
        }
    }
}

Output: B x

Der Unicode-Wert von 'B' ist '\u0042', daher druckt ch1 'B'.

---

Decimal

• Decimal-Typ hat mehr Precision und kleineren Bereich im Vergleich zu Gleitkommatypen (double und float). Daher geeignet für monetäre Berechnungen.
• Größe: 128 Bit
• Standardwert: 0,0M [M am Ende kennzeichnet decimal-Typ]
• Bereich: (-7,9 × 10²⁸ bis 7,9 × 10²⁸) / (10⁰ bis 10²⁸)

Beispiel:

using System;
namespace DataType
{
    class DecimalExample
    {
        public static void Main(string[] args)
        {
            decimal bankBalance = 53005.25M;
            Console.WriteLine(bankBalance);
        }
    }
}

Output: 53005.25

Der Suffix M oder m muss am Ende hinzugefügt werden, andernfalls wird der Wert als double behandelt und ein Fehler generiert.

---

C# Literale

Betrachten Sie folgende Anweisung:

int number = 41;

Hier ist:

• int ein Datentyp
• number eine Variable und
• 41 ein Literal

Literale sind feste Werte, die im Programm auftauchen. Sie erfordern keine Berechnung. Zum Beispiel sind 5, false, 'w' Literale, die direkt im Programm ohne Berechnung erscheinen.

---

Boolean-Literale

• true und false sind die verfügbaren Boolean-Literale.
• Sie werden zur Initialisierung von Boolean-Variablen genutzt.

Beispiel:

bool isValid = true;
bool isPresent = false;

---

Integer-Literale

• Integer-Literale initialisieren Variablen von Integer-Datentypen: sbyte, short, int, long, byte, ushort, uint, ulong.
• Endet ein Integer-Literal mit L oder l, ist es vom Typ long. Best Practice: L (nicht l) nutzen.

  long value1 = 4200910L;
  long value2 = -10928190L;

• Beginnt ein Integer-Literal mit 0x, stellt es einen Hexadezimalwert dar. Werte ohne Präfix sind dezimal. Oktal und Binär sind in C# nicht erlaubt.

  int decimalValue = 25;
  int hexValue = 0x11c; // dezimaler Wert 284

---

Gleitkomma-Literale

• Gleitkomma-Literale initialisieren float- und double-Variablen.
• Endet ein Literal mit Suffix f oder F, ist es Typ float. Mit d oder D Typ double. Fehlt beides, ist es standardmäßig double.
• Diese Literale enthalten e oder E in wissenschaftlicher Notation.

  double number = 24.67; // double by default
  float value = -12.29F;
  double scientificNotation = 6.21e2; // äquivalent 6,21 × 10² = 621

---

Zeichen- und String-Literale

• Zeichenliterale initialisieren char-Variablen.
• Zeichenliterale stehen in einfachen Anführungszeichen. Z. B. 'x', 'p'.
• Sie können als Zeichen, Hex-Escape-Sequenz, Unicode-Darstellung oder als Integer gecastet zu char dargestellt werden.

  char ch1 = 'R'; // Zeichen
  char ch2 = '\x0072'; // hexadezimal
  char ch3 = '\u0059'; // unicode
  char ch4 = (char)107; // gecastet von Integer

• Stringliterale sind Sammlungen von Zeichenliteralen.
• Sie stehen in doppelten Anführungszeichen. Z. B. "Hello", "Easy Programming".

  string firstName = "Richard";
  string lastName = " Feynman";

• C# unterstützt auch Escape-Sequenzen:

  Zeichen	Bedeutung
  \'	Einfaches Anführungszeichen
  \"	Doppeltes Anführungszeichen
  \\	Backslash
  \n	Neue Zeile
  \r	Wagenrücklauf
  \t	Horizontaler Tab
  \a	Alert
  \b	Backspace