0Pricing
C# Academy · Lektion

Null-bedingte und Null-Koaleszenz-Operatoren

Kombinieren Sie ?., ?[], ?? und ??= für prägnanten, nullsicheren Code ohne ausführliche Nullprüfungen.

Null-bedingte und Null-Koaleszenz-Operatoren ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Muster für null-sicheren Code

C# stellt drei spezielle Operatoren bereit, um null-Werte präzise zu behandeln: den nullbedingten Operator (?., ?[]), den Nullkoaleszenzoperator (??) und den Nullkoaleszenz-Zuweisungsoperator (??=). Zusammen machen sie den meisten ausführlichen Nullprüfungs-Code überflüssig.

Nullbedingter Operator: ?.

?. ergibt null, wenn die linke Seite null ist, statt eine NullReferenceException auszulösen. Der Ergebnistyp wird dadurch nullable.

User? user = GetUser(id);

// Without ?.:
string? name = null;
if (user != null) name = user.Name;

// With ?.:
string? name2 = user?.Name;

// Chained:
string? city = user?.Address?.City;

// Method call:
string? upper = user?.Name?.ToUpper();

Nullbedingter Indexzugriff: ?[]

?[] ist der nullbedingte Indexoperator. Er greift sicher auf Elemente eines Arrays oder einer Sammlung zu, wenn die Sammlung selbst null sein kann.

List<string>? tags = product?.Tags;

// Safe index access
string? firstTag = tags?[0];

// Null-conditional LINQ
int? count = tags?.Count;
bool? hasItems = tags?.Any();

// With methods:
string? joined = tags?.FirstOrDefault()?.ToUpper();

Nullkoaleszenzoperator: ??

?? gibt den linken Operanden zurück, wenn er nicht null ist, andernfalls den rechten Operanden (den Ersatzwert). Er ist die präzise Alternative zu x != null ? x : fallback.

string? name = GetName();

// Without ??:
string display = name != null ? name : "Anonymous";

// With ??:
string display2 = name ?? "Anonymous";

// Chaining ?? for multiple fallbacks:
string result = primary ?? secondary ?? tertiary ?? "Default";

// Combining with ?.
string city = user?.Address?.City ?? "Unknown City";

Null-Koaleszenz-Zuweisung: ??=

??= weist die rechte Seite der Variablen nur dann zu, wenn die Variable derzeit null ist. Das eignet sich ideal für Muster zur verzögerten Initialisierung.

// Lazy initialization
private List<string>? _cache;

public List<string> GetCache()
{
    _cache ??= new List<string>(); // only assigns if null
    return _cache;
}

// Equivalent to:
// if (_cache is null) _cache = new List<string>();

// In-place:
string? name = null;
name ??= "Default";
Console.WriteLine(name); // "Default"

Verwendung von ?. mit Ereignissen

Der Null-bedingte Operator ist die standardmäßige threadsichere Möglichkeit, Ereignisse aufzurufen – er vermeidet die Race Condition einer getrennten Nullprüfung und des anschließenden Aufrufs.

public event EventHandler<DataEventArgs>? DataReceived;

// Thread-safe event invocation:
DataReceived?.Invoke(this, new DataEventArgs(data));

// This is equivalent to:
var handler = DataReceived;
if (handler != null) handler(this, new DataEventArgs(data));
// (local copy avoids race condition between check and invoke)

Komplexe Verkettungsbeispiele

Durch das Kombinieren der Operatoren können Sie sauber und lesbar durch tief verschachtelte Objektstrukturen navigieren, ohne Nullreferenzen zu riskieren.

var order = GetOrder(id);

// Deeply nested with fallbacks:
string countryCode = order
    ?.Customer
    ?.ShippingAddress
    ?.Country
    ?.Code
    ?? "US";

// Collection safe access:
decimal firstLineTotal = order
    ?.Lines
    ?.FirstOrDefault()
    ?.Total
    ?? 0m;

// Method chain:
string? trackingUpper = order?.TrackingNumber?.ToUpper().Trim();

Null-bedingter Operator in LINQ

Der Null-bedingte Operator funktioniert nahtlos mit LINQ und ermöglicht sichere Abfragen für möglicherweise nullbare Sammlungen oder Eigenschaften.

List<Order>? orders = customer?.Orders;

// Safe LINQ on a nullable collection:
var totalRevenue = orders?.Sum(o => o.Total) ?? 0m;
var pendingCount = orders?.Count(o => o.Status == OrderStatus.Pending) ?? 0;
var latest       = orders?.MaxBy(o => o.PlacedAt)?.Id;

Nullprüfungen mit ThrowIfNull

Für Parameter, die nicht null sein dürfen, verwenden Sie ArgumentNullException.ThrowIfNull() (.NET 6+), um beim Methodeneinstieg eine kompakte, aussagekräftige Validierung durchzuführen.

public void ProcessOrder(Order order, Customer customer)
{
    ArgumentNullException.ThrowIfNull(order);
    ArgumentNullException.ThrowIfNull(customer);

    // From this point, compiler knows both are non-null
    Console.WriteLine(order.Id);
    Console.WriteLine(customer.Name);
}

// .NET 7+: ArgumentException.ThrowIfNullOrEmpty
void Save(string name)
{
    ArgumentException.ThrowIfNullOrWhiteSpace(name);
    // name is guaranteed non-empty
}

„Is Not Null“-Muster in Switch

Pattern Matching mit is not null und is { } ermöglicht klare Muster zur Nullprüfung, besonders in switch-Ausdrücken.

string Describe(object? obj) => obj switch
{
    null                          => "nothing",
    string s when s.Length == 0  => "empty string",
    string s                      => $"string: {s}",
    int i                         => $"integer: {i}",
    { }                           => $"object: {obj.GetType().Name}"
};

// is not null in if statements:
if (order is not null && order.Customer is { Name: var name })
    Console.WriteLine(name);

Schnelltest

Was gibt der Ausdruck user?.Name ?? "Anonymous" zurück, wenn user null ist?

Zusammenfassung: Null-bedingte Operatoren und Null-Koaleszenz

Wichtige Erkenntnisse:

  • ?.: sicherer Memberzugriff – gibt null zurück, statt bei einem null-Receiver eine Ausnahme auszulösen
  • ?[]: sicherer Indexzugriff auf möglicherweise nullbare Sammlungen
  • ??: Fallback-Wert, wenn der linke Operand null ist
  • ??=: nur bei null zuweisen – ideal für die verzögerte Initialisierung
  • Kombinieren Sie sie: a?.B?.C ?? defaultVal für eine tiefgehende Navigation ohne Nullreferenzen
  • ArgumentNullException.ThrowIfNull() für Nullprüfungen von Parametern

Häufig gestellte Fragen

Ist die Lektion „Null-bedingte und Null-Koaleszenz-Operatoren“ kostenlos?

Ja — der vollständige Text von „Null-bedingte und Null-Koaleszenz-Operatoren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Null-bedingte und Null-Koaleszenz-Operatoren“?

Kombinieren Sie ?., ?[], ?? und ??= für prägnanten, nullsicheren Code ohne ausführliche Nullprüfungen. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Null-bedingte und Null-Koaleszenz-Operatoren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. NRT aktivieren und verstehen
  2. Annotationen: ?, !, MaybeNull und NotNull
  3. Null-bedingte und Null-Koaleszenz-Operatoren
  4. Eine Codebasis auf NRT migrieren
← Zurück zu C# Academy