C# Datentypen: int, double, decimal, char, bool und ihre Wertebereiche

C# ist statisch typisiert: Jede Variable, jedes Feld und jeder Ausdruck hat einen zur Kompilierzeit bekannten Typ. Die Sprache hat eine Reihe eingebauter Typen mit eigenen Schlüsselwörtern (int, double, string...). Jedes Schlüsselwort ist ein Alias für einen Typ im Namespace System, also sind int und System.Int32 derselbe Typ, ebenso string und System.String.

Die eingebauten Typen

Ein Ganzzahl-Literal ohne Suffix ist ein int, oder der erste Typ aus uint, long und ulong, der es aufnehmen kann, wenn es für ein int zu groß ist, und ein Literal mit Dezimalpunkt ist ein double. Deshalb kompilieren float f = 2.5; und decimal d = 2.5; nicht: Das Literal ist ein double, und es gibt keine implizite Umwandlung von double in float oder decimal. Hänge das Suffix an: 2.5f, 2.5m.

Jeder numerische Typ stellt seine Grenzen als Konstanten bereit:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine($"byte:  {byte.MinValue} to {byte.MaxValue}");
        Console.WriteLine($"short: {short.MinValue} to {short.MaxValue}");
        Console.WriteLine($"int:   {int.MinValue} to {int.MaxValue}");
        Console.WriteLine($"long:  {long.MinValue} to {long.MaxValue}");
        Console.WriteLine($"decimal max: {decimal.MaxValue}");
        Console.WriteLine($"double max:  {double.MaxValue:E3}");
        Console.WriteLine($"sizes: int {sizeof(int)}, long {sizeof(long)}, double {sizeof(double)}, char {sizeof(char)}");

        int hex = 0xFF;             // hexadecimal
        int bits = 0b1010_0001;     // binary (C# 7)
        long big = 3_000_000_000;   // digit separators (C# 7)
        Console.WriteLine($"{hex} {bits} {big}");
    }
}

Ausgabe:

byte:  0 to 255
short: -32768 to 32767
int:   -2147483648 to 2147483647
long:  -9223372036854775808 to 9223372036854775807
decimal max: 79228162514264337593543950335
double max:  1.798E+308
sizes: int 4, long 8, double 8, char 2
255 161 3000000000

In der Praxis nutzt der meiste Code vier davon: int für Zähler und Indizes, long für IDs und große Summen, double für Messwerte und Mathematik und decimal für Geld.

decimal vs. double

double (und float) speichern Zahlen binär. Die meisten Dezimalbrüche, auch 0.1, haben keine exakte binäre Form, deshalb wird der nächstgelegene darstellbare Wert gespeichert, und kleine Fehler summieren sich. decimal speichert eine Ganzzahl zur Basis 10 plus eine Skalierung, also ist 0.1 exakt 0.1.

using System;

class Program
{
    static void Main()
    {
        double a = 0.1 + 0.2;
        decimal b = 0.1m + 0.2m;
        Console.WriteLine(a == 0.3);          // False
        Console.WriteLine(b == 0.3m);         // True
        Console.WriteLine(a.ToString("G17")); // 17 significant digits
        Console.WriteLine(b);

        double dsum = 0;
        decimal msum = 0;
        for (int i = 0; i < 10; i++)
        {
            dsum += 0.1;
            msum += 0.1m;
        }
        Console.WriteLine($"double sum == 1.0: {dsum == 1.0}");
        Console.WriteLine($"decimal sum == 1.0: {msum == 1.0m}");

        decimal price = 19.99m;
        int quantity = 3;
        decimal total = price * quantity;
        Console.WriteLine($"Total: {total}");
        Console.WriteLine($"Split three ways: {total / 3}");
    }
}

Ausgabe:

False
True
0.30000000000000004
0.3
double sum == 1.0: False
decimal sum == 1.0: True
Total: 59.97
Split three ways: 19.99

Nimm decimal für Geld, Preise, Steuern und alles, was ein Mensch von Hand zusammenrechnet und vergleicht. Es behält nachgestellte Nullen aus seinen Eingaben (1.50m wird als 1.50 ausgegeben) und hat 28 bis 29 signifikante Stellen.

Nimm double für physikalische Messwerte, Statistik, Geometrie und Spiele. Es ist um ein Mehrfaches schneller, braucht halb so viel Speicher, und sein Wertebereich ist riesig. Vergleiche zwei berechnete Doubles nie mit ==; vergleiche die Differenz mit einer Toleranz: Math.Abs(x - y) < 1e-9.

decimal ist keine Magie: 1m / 3m ist trotzdem 0.3333333333333333333333333333, und double-Arithmetik wirft bei Division durch null keine Exception (sie ergibt Unendlich, oder NaN bei 0.0 / 0.0), während Division durch null bei decimal und Ganzzahlen eine DivideByZeroException wirft.

Integer-Überlauf und checked

Ganzzahlarithmetik, die den Wertebereich des Typs überschreitet, läuft standardmäßig über und springt stillschweigend um. Der Compiler erkennt Überläufe in konstanten Ausdrücken, aber nicht, wenn die Werte aus Variablen kommen:

using System;

class Program
{
    static void Main()
    {
        int max = int.MaxValue;
        int wrapped = max + 1;           // no error: wraps around
        Console.WriteLine(wrapped);

        try
        {
            int safe = checked(max + 1); // throws instead of wrapping
            Console.WriteLine(safe);
        }
        catch (OverflowException)
        {
            Console.WriteLine("OverflowException");
        }

        long views = 3_000_000_000;
        int truncated = unchecked((int)views); // explicit narrowing keeps low 32 bits
        Console.WriteLine(truncated);

        long total = (long)max + 1;       // widen first to get the right answer
        Console.WriteLine(total);
    }
}

Ausgabe:

-2147483648
OverflowException
-1294967296
2147483648

checked(...) oder ein Block checked { ... } macht aus einem Überlauf eine OverflowException. Du kannst das auch für das ganze Projekt mit <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow> einschalten. int x = int.MaxValue + 1; mit Konstanten zu schreiben ist ein Kompilierfehler (CS0220), weil der Compiler den Überlauf sieht.

Die letzte Zeile zeigt die Lösung für die meisten Überlauffehler: vor der Arithmetik in einen breiteren Typ umwandeln. (long)(max + 1) wäre falsch, denn die Addition ist bereits übergelaufen, wenn der Cast ausgeführt wird.

Werttypen und Referenztypen

Jeder C#-Typ ist entweder ein Werttyp oder ein Referenztyp, und dieser Unterschied entscheidet, was eine Zuweisung tut.

• Werttypen: alle numerischen Typen, bool, char, DateTime, Enums und jedes struct. Die Variable enthält die Daten; eine Zuweisung kopiert sie.
• Referenztypen: string, Arrays, object und jede class. Die Variable enthält eine Referenz auf ein Objekt; eine Zuweisung kopiert die Referenz, sodass beide Variablen dasselbe Objekt sehen.

using System;

class Program
{
    static void Main()
    {
        int a = 10;
        int b = a;      // copy of the value
        b = 99;
        Console.WriteLine($"a={a} b={b}");

        int[] first = { 1, 2, 3 };
        int[] second = first;   // copy of the reference
        second[0] = 99;
        Console.WriteLine($"first[0]={first[0]}");

        string s1 = "cat";
        string s2 = s1;
        s2 += "s";              // strings are immutable: s2 now refers to a new string
        Console.WriteLine($"s1={s1} s2={s2}");
    }
}

Ausgabe:

a=10 b=99
first[0]=99
s1=cat s2=cats

string ist ein Referenztyp, der sich in der Praxis wie ein Wert verhält: Er ist unveränderlich, und == vergleicht den Text, nicht die Referenzen. Mehr über benutzerdefinierte Werttypen unter Structs.

char und bool

Ein char ist eine UTF-16-Codeeinheit und wird in einfachen Anführungszeichen geschrieben. Darunter ist es ein numerischer Typ, es lässt sich also in int umwandeln und unterstützt Arithmetik:

using System;

class Program
{
    static void Main()
    {
        char grade = 'B';
        Console.WriteLine((int)grade);           // 66
        Console.WriteLine((char)(grade + 1));    // C
        Console.WriteLine(char.IsLetter(grade));
        Console.WriteLine(char.IsDigit('7'));
        Console.WriteLine('7' - '0');             // digit char to its value
        Console.WriteLine(char.ToLower(grade));

        bool isOpen = true;
        bool hasStock = false;
        Console.WriteLine(isOpen && !hasStock);
    }
}

Ausgabe:

66
C
True
True
7
b
True

bool hat genau zwei Werte und lässt sich nicht in Zahlen umwandeln oder aus ihnen erzeugen: if (count) ist ein Kompilierfehler, kein Test auf ungleich null. Schreibe if (count != 0). Zeichen außerhalb der Basic Multilingual Plane, etwa die meisten Emojis, belegen zwei char-Werte (ein Surrogatpaar), daher zählt die Length eines string UTF-16-Einheiten, keine sichtbaren Zeichen.

Standardwerte

Felder, Array-Elemente und default(T) bekommen den Standardwert des Typs: null für Zahlen, false für bool, '\0' für char und null für Referenztypen. Lokale Variablen bekommen keinen Standardwert und müssen vor der Verwendung zugewiesen werden.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine(default(int));
        Console.WriteLine(default(decimal));
        Console.WriteLine(default(bool));
        Console.WriteLine(default(string) == null);
        Console.WriteLine(default(DateTime).ToString("yyyy-MM-dd"));

        var counts = new int[3];
        Console.WriteLine(string.Join(",", counts));
    }
}

Ausgabe:

0
0
False
True
0001-01-01
0,0,0

Seit C# 7.1 kannst du das Literal default ohne den Typ schreiben, wenn der Compiler ihn ableiten kann (int x = default;). Ein Werttyp kann nicht null sein, dafür gibt es int? (einen Nullable-Werttyp); siehe Nullable-Typen.

Ganzzahlen in Zeigergröße und beliebig große Ganzzahlen

Für Sonderfälle gibt es zwei weitere numerische Typen. nint und nuint (C# 9) sind Ganzzahlen in Zeigergröße, je nach Plattform 32 oder 64 Bit, und werden in Interop- und Low-Level-Code verwendet. System.Numerics.BigInteger nimmt Ganzzahlen beliebiger Größe auf, auf Kosten der Geschwindigkeit:

using System.Numerics;
BigInteger factorial = 1;
for (int i = 2; i <= 30; i++) factorial *= i;
// 265252859812191058636308480000000