Nullwertetypen: C#-Grundlagen

Tipp

Dieser Artikel ist Teil des Abschnitts "Grundlagen" für Entwickler, die mindestens eine Programmiersprache kennen und C# erlernen. Wenn Sie noch nicht mit der Programmierung vertraut sind, beginnen Sie zuerst mit den Lernprogrammen " Erste Schritte ". Weitere Informationen finden Sie unter Nullwertetypen in der Sprachreferenz.

Ein NullwerttypT? stellt alle Werte des zugrunde liegenden Werttyps Tsowie einen zusätzlichen null Wert dar. Eine Variable des Typs int? enthält eine ganze Zahl oder null einen Wert, der "kein Wert" darstellt.

Werttypen wie z. B. int, bool und DateTime können standardmäßig null nicht enthalten. Dieses Verhalten ist effizient und verhindert viele Fehler. Diese Einschränkung verursacht jedoch ein Problem, wenn ein Wert möglicherweise nicht vorhanden ist. Ein häufiges Szenario ist das Lesen aus einer Datenbank: Eine ganzzahlige Spalte kann eine Zahl enthalten, oder sie enthält überhaupt keinen Wert (NULL in SQL). Eine einfache int Kann diese Abwesenheit nicht darstellen, aber int? kann.

Deklaration eines Nullable-Werttyps

An einen beliebigen Werttyp ? anfügen, damit er nullfähig wird:

int?    age      = null;    // integer with no value yet
double? price    = 9.99;    // nullable double with a value
bool?   isActive = null;    // boolean with no value

age = 30;                   // assign a value later

int?[] scores = [100, null, 85, null, 72]; // array with absent entries

Der Standardwert eines Nullwerttyps ist null, nicht der Standardwert des zugrunde liegenden Typs.

Überprüfen, ob ein Wert vorhanden ist

Die empfohlene Methode zum Überprüfen eines nullfähigen Werttyps und zum Extrahieren seines Werts ist ein Typmuster:

int? temperature = 72;

if (temperature is int degrees)
{
    Console.WriteLine($"Temperature is {degrees}°F.");
}
else
{
    Console.WriteLine("Temperature is not recorded.");
}
// Output: Temperature is 72°F.

Das is int degrees-Muster trifft nur zu, wenn temperature nicht null ist, und bindet gleichzeitig den Wert an degrees. Sie erhalten sowohl die NULL-Prüfung als auch die Wertextraktion in einem Schritt.

Alternativ verwenden Sie die HasValue- und Value-Eigenschaften.

int? count = 42;

if (count.HasValue)
{
    Console.WriteLine($"Count is {count.Value}.");
}
else
{
    Console.WriteLine("Count has no value.");
}
// Output: Count is 42.

Bevorzugen Sie das is T value Muster für neuen Code. Es führt eine neue nicht-nullbare Variable ein, die der übereinstimmenden Verzweigung zugeordnet ist, wodurch die Absicht klarer wird und jede Versuchung beseitigt wird, Value versehentlich außerhalb einer NULL-Prüfung zu nutzen, wo ein InvalidOperationException ausgelöst würde.

Sie können auch direkt mit null:

int? quantity = null;

if (quantity != null)
{
    Console.WriteLine($"Quantity: {quantity.Value}");
}
else
{
    Console.WriteLine("Quantity is not set.");
}
// Output: Quantity is not set.

Einen Wert mit Fallback abrufen

Wenn Sie einen nicht-nullbaren Wert aus einem nullbaren Wert benötigen, verwenden Sie den GetValueOrDefault oder den nullkoalierenden Operator ??.

int? rating = null;

int result1 = rating.GetValueOrDefault();    // 0 (default for int)
int result2 = rating.GetValueOrDefault(-1);  // -1 (specified fallback)

Console.WriteLine(result1); // 0
Console.WriteLine(result2); // -1

rating = 5;
int result3 = rating.GetValueOrDefault(-1);  // 5 (actual value)
Console.WriteLine(result3); // 5

Der ?? Operator ist oft sauberer in der Zeile:

int? priority = null;

int effective = priority ?? 0;  // 0 because priority is null
Console.WriteLine(effective);   // 0

priority  = 3;
effective = priority ?? 0;      // 3 because priority has a value
Console.WriteLine(effective);   // 3

Beide Ansätze geben den tatsächlichen Wert zurück, wenn ein Wert vorhanden ist, und den von angegebenen Ersatzwert, falls keiner vorhanden ist.

Arithmetisch mit nullablen Werttypen

Arithmetische und Vergleichsoperatoren für nullbare Werttypen werden gehoben: Wenn ein Operand null ist, ist das Ergebnis null statt eines Fehlers.

int? a = 10;
int? b = 20;
int? c = null;

int? sum     = a + b;   // both non-null: result is 30
int? product = a * c;   // one operand is null: result is null

Console.WriteLine(sum);               // 30
Console.WriteLine(product.HasValue);  // False — null propagates through arithmetic

Null wird standardmäßig durch Arithmetik weitergeleitet. Um zu verhindern, dass ein NULL-Ergebnis weiter überlappen kann, extrahieren Sie den Wert mit ?? oder GetValueOrDefault bevor Sie es in einer Berechnung verwenden.

Siehe auch

  • Last updated on