C# Null-Bedingungs-Operator

Schnelle Erklärung durch Docs-Seite

Gerald beginnt mit einem Verweis auf die offizielle Microsoft-Dokumentation zu Operatoren und Ausdrücken für den Mitgliederzugriff. Er hebt den Abschnitt über den Null-Bedingungsoperator hervor, der in C# 6 eingeführt wurde. Zum Zeitpunkt der Aufzeichnung war C# 9 die neueste Version, und C# 10 ist in Sicht.

Gerald erklärt, dass wenn Sie a?.x oder a?[index] verwenden und a null ist, wird der gesamte Ausdruck zu null bewertet, anstatt eine NullReferenceException auszulösen. Ansonsten wird der Wert normal wiedergegeben.

Die Dokumentation ist zwar hilfreich, aber Gerald bevorzugt praktische Beispiele, weshalb er zu einer interaktiven Programmierumgebung übergeht.

Beispiel durch try.dot.net

Zur Demonstration wechselt Gerald zu try.dot.net, einer interaktiven C#-Umgebung. Er erwähnt, dass dieses Tool auf Blazor läuft und es den Benutzern ermöglicht, C#-Code direkt in einem Browser auszuführen.

Er zeigt kurz das Standardbeispiel der Fibonacci-Folge, das in try.dot.net vorgeladen ist, und löscht es dann, um ein neues Beispiel zu starten, das sich auf den Null-Bedingungsoperator konzentriert.

Null-Bedingungs-Operatoren erklärt

Gerald erstellt eine einfache Personenklasse mit den folgenden Eigenschaften:

public class Person
{
    // The Name property of the Person
    public string Name { get; set; }

    // A reference to another Person object representing the partner
    public Person Partner { get; set; }

    // An array representing the Person's hobbies
    public string[] Hobbies { get; set; }
}

public class Person
{
    // The Name property of the Person
    public string Name { get; set; }

    // A reference to another Person object representing the partner
    public Person Partner { get; set; }

    // An array representing the Person's hobbies
    public string[] Hobbies { get; set; }
}

Er initialisiert ein Person-Objekt als null:

// Initialize a Person object as null
Person person = null;

// Attempting to access a property of a null object will throw a NullReferenceException
Console.WriteLine(person.Name);

// Initialize a Person object as null
Person person = null;

// Attempting to access a property of a null object will throw a NullReferenceException
Console.WriteLine(person.Name);

Das Ausführen dieses Codes löst eine NullReferenceException aus, weil person null ist. Um dies zu verhindern, fügen Entwickler in der Regel eine Nullprüfung vor dem Zugriff auf Eigenschaften hinzu:

// Check if the person object is not null before accessing its properties
if (person != null)
{
    Console.WriteLine(person.Name);
}

// Check if the person object is not null before accessing its properties
if (person != null)
{
    Console.WriteLine(person.Name);
}

Dies funktioniert zwar, führt aber zusätzliche Codezeilen ein. Gerald erklärt, wie der Null-Bedingungsoperator dies vereinfacht:

// Using the null-conditional operator to safely access the Name property
Console.WriteLine(person?.Name);

// Using the null-conditional operator to safely access the Name property
Console.WriteLine(person?.Name);

Jetzt, wenn person null ist, gibt der Ausdruck einfach null zurück, anstatt abzustürzen.

Null-Bedingungs-Operator für Eigenschaften

Gerald erweitert das Beispiel, indem er ein Person-Objekt einrichtet:

// Create a new Person object
Person person = new Person { Name = "Gerald" };

// Access the Name property safely
Console.WriteLine(person?.Name);

// Create a new Person object
Person person = new Person { Name = "Gerald" };

// Access the Name property safely
Console.WriteLine(person?.Name);

Da person nicht null ist, wird korrekt "Gerald" ausgegeben.

Als nächstes zeigt er ein verschachteltes Beispiel:

// Safely access the Name property of the Partner object
Console.WriteLine(person?.Partner?.Name);

// Safely access the Name property of the Partner object
Console.WriteLine(person?.Partner?.Name);

Wenn person.Partner null ist, wird der gesamte Ausdruck zu null bewertet, anstatt eine Ausnahme auszulösen. Dadurch werden unnötige Wenn-Bedingungen vermieden.

Ketten von Null-Bedingungs-Operatoren

Gerald erklärt, dass Null-Bedingungs-Operatoren verkettet werden können, was den Code sauberer macht, wenn man mit tief verschachtelten Objekten arbeitet. Anstatt mehrere Nullprüfungen zu schreiben, können Sie verwenden:

// Chain null-conditional operators to safely access nested objects
Console.WriteLine(person?.Partner?.Name);

// Chain null-conditional operators to safely access nested objects
Console.WriteLine(person?.Partner?.Name);

Wenn person oder person.Partner null ist, wird das Ergebnis null sein, was Laufzeitfehler verhindert.

Null-Bedingungs-Operatoren auf Arrays

Gerald dehnt die Diskussion auf Arrays und Sammlungen aus. Er fügt der Klasse Person ein Array Hobbies hinzu und zeigt, wie man sicher auf Elemente zugreift:

// Safely access the first element of the Hobbies array
Console.WriteLine(person?.Hobbies?[0]);

// Safely access the first element of the Hobbies array
Console.WriteLine(person?.Hobbies?[0]);

Hier, wenn person oder Hobbies null ist, wird der Ausdruck zu null bewertet, anstatt eine Ausnahme zu verursachen.

Abschluss

Geralds Video bietet einen detaillierten Einblick in den Null-Bedingungsoperator in C#. Durch die Verwendung von ?. und ?[ ] können Entwickler saubereren, sichereren Code schreiben, der NullReferenceException vermeidet. Egal, ob es um Eigenschaften, verschachtelte Objekte oder Arrays geht, der Null-Bedingungsoperator macht den Code prägnanter und lesbarer.

Eine vollständige Demonstration finden Sie im Video von Gerald Versluis, in dem er alles mit praktischen Beispielen erklärt!