Null-Parameter-Prüfungen in C# 10 und .NET 6 in 10 Minuten oder weniger

Die Bühne bereiten - Prüfung auf Null-Parameter

Tim beginnt mit der Erstellung einer einfachen .NET 6-Konsolenanwendung, um zu zeigen, wie Null-Parameter-Prüfungen in C# gehandhabt werden. Er löscht den Boilerplate-Code und deklariert eine nullbare String-Variable:

string? info = null;

string? info = null;

Dieses Null-Objekt stellt ein Szenario dar, in dem ein Methodenaufruf ein Argument erhält, das nicht richtig instanziiert wurde. Tim definiert dann eine einfache Methode:

void SayHi(string message)
{
    Console.WriteLine($"Hallo {message}");
}

void SayHi(string message)
{
    Console.WriteLine($"Hallo {message}");
}

Er übergibt die Variable info an die Methode:

SayHi(info);

SayHi(info);

Wenn das Programm ausgeführt wird, wird die Ausgabe einfach angezeigt:

Hallo

Es tritt keine Ausnahme auf, da die String-Verkettung einen Null-Wert akzeptiert und ihn wie einen leeren String behandelt. Aber, wie Tim betont, kann dies in den meisten realen Methoden zu fehleranfälligen Situationen führen, in denen eine Null-Referenz zu nachgelagerten Problemen oder einer NullReferenceException später im Aufrufstapel führt.

Um robusten Code zu erstellen, sollten Entwickler Argumente validieren und sicherstellen, dass jede Methode gültige Eingaben erwartet, die nicht null sind.

Traditionelle Nullprüfung vor C# 10

Tim erklärt, dass es sich vor C# 10 bewährt hat, Parameter manuell zu überprüfen und bei Bedarf eine ArgumentNullException auszulösen. Innerhalb der SayHi-Methode, fügt er hinzu:

if (message is null)
    throw new ArgumentNullException(nameof(message));

if (message is null)
    throw new ArgumentNullException(nameof(message));

Diese Prüfung stellt sicher, dass das Programm bei Übergabe eines Null-Arguments sofort eine neue Instanz der Klasse ArgumentNullException auslöst.

Wenn Tim den Code ausführt, wird die Fehlermeldung deutlich angezeigt:

System.ArgumentNullException: Value cannot be null. (Parameter 'message')

System.ArgumentNullException: Value cannot be null. (Parameter 'message')

Diese unbehandelte Ausnahme zeigt an, dass die Methode ein ungültiges Argument erhalten hat. Der Parametername - in diesem Fall "message" - wird automatisch in der Ausgabe angezeigt, damit der Entwickler genau erkennen kann, welches Argument das Problem verursacht hat.

Tim merkt an, dass dieser Handbuch-Check perfekt mit dem .NET Framework und früheren .NET Core-Versionen funktioniert. Sie ist jedoch langatmig und repetitiv, wenn es um mehrere Parameter geht. Jeder zusätzliche Parameter, der validiert werden muss, fügt drei oder vier Codezeilen hinzu und verunreinigt den Methodenkörper.

Die vereinfachte Herangehensweise in C# 10 - ArgumentNullException.ThrowIfNull()

An dieser Stelle stellt Tim die moderne C# 10-Syntax vor. Anstatt mehrere Zeilen für jeden Parameter zu schreiben, können Entwickler jetzt eine einzige Zeile für die Nullprüfung schreiben:

ArgumentNullException.ThrowIfNull(message);

ArgumentNullException.ThrowIfNull(message);

Tim erklärt, dass dieser Einzeiler intern die gleiche Validierungslogik durchführt. Wenn das übergebene Argument null ist, löst die Methode automatisch eine Ausnahme aus - genau wie zuvor, aber mit einer viel saubereren Syntax.

Wenn das Programm erneut ausgeführt wird, erscheint die folgende Ausgabe:

System.ArgumentNullException: Value cannot be null. (Parameter 'message')

System.ArgumentNullException: Value cannot be null. (Parameter 'message')

Das Verhalten bleibt identisch, aber die Syntax ist jetzt vereinfacht. Es ist nicht erforderlich, ein neues ArgumentNullException-Objekt manuell über einen Konstruktor zu instanziieren oder den Parameter paramName manuell anzugeben. Der Parametername des Aufrufers wird automatisch vom Compiler abgeleitet.

Tim betont, dass diese Verbesserung Zeit spart und die Gefahr menschlicher Fehler bei der Angabe des falschen Parameternamens verringert.

Beispiel: Mehrere Parameter

Anschließend vergleicht Tim die traditionelle Methode mit der neuen bei der Handhabung mehrerer Parameter.

Vor C# 10 könnte ein Entwickler schreiben:

if (name is null)
    throw new ArgumentNullException(nameof(name));
if (email is null)
    throw new ArgumentNullException(nameof(email));
if (password is null)
    throw new ArgumentNullException(nameof(password));

if (name is null)
    throw new ArgumentNullException(nameof(name));
if (email is null)
    throw new ArgumentNullException(nameof(email));
if (password is null)
    throw new ArgumentNullException(nameof(password));

Mit der C# 10-Erweiterung können dieselben Prüfungen jetzt noch prägnanter geschrieben werden:

ArgumentNullException.ThrowIfNull(name);
ArgumentNullException.ThrowIfNull(email);
ArgumentNullException.ThrowIfNull(password);

ArgumentNullException.ThrowIfNull(name);
ArgumentNullException.ThrowIfNull(email);
ArgumentNullException.ThrowIfNull(password);

Bei dieser Verbesserung geht es nicht nur um weniger Zeilen, sondern auch darum, dass Ihre Methoden sauberer, lesbarer und leichter zu pflegen sind. Tim merkt an, dass Sie für eine Methode, die drei Parameter erwartet, nur noch drei Null-Prüfungen benötigen, statt zwölf Zeilen Code.

Warum dies wichtig ist - Sicherer, robuster Code

Tim weist darauf hin, dass die manuelle Übergabe von Null an eine Zeichenkette in einer Demo zwar nicht realistisch ist, aber reale Probleme darstellt. APIs, Benutzereingaben, Deserialisierungsprozesse oder Operationen, bei denen Objekte zurückgegeben werden, können unerwartet Null-Objekte ergeben.

Durch das Hinzufügen von Null-Prüfungen am Anfang einer Methode verhindern Sie unerwartetes Verhalten und scheitern schnell, d. h. das Programm löst früh im Aufrufstapel eine Ausnahme aus, bevor sich das Problem ausbreitet.

Er erwähnt auch, dass diese neue Syntax Ihnen hilft, konsistente Fehlerbehandlungsmuster über Ihre Methoden hinweg beizubehalten. Sie ermutigt dazu, robusten Code zu schreiben, der gegen ungültige Eingaben und unkonventionelle Objekte resistent ist.

Details zur ArgumentNullException

Tim hebt hervor, dass ArgumentNullException Teil des System-Namensraums ist und von der ArgumentException-Klasse erbt. Es wird ausgelöst, wenn eine Null-Referenz an eine Methode übergeben wird, die sie nicht als gültiges Argument akzeptiert.

Sie umfasst in der Regel:

• Der Parametername, der das Problem verursacht hat.

• Eine klare Fehlermeldung: "Value cannot be null."

• Der Aufrufstapel, der zeigt, wo die Ausnahme aufgetreten ist.

Das Beispiel von Tim zeigt, wie .NET 6 dieses Verhalten beibehält und gleichzeitig die Syntax verbessert.

Er weist auch kurz darauf hin, dass Entwickler diese Prüfungen mit anderen Funktionen wie dem Null-Koaleszenz-Operator (??) oder Standardwerten kombinieren können, um eine Fallback-Logik bereitzustellen - zum Beispiel:

message ??= "Default message";

message ??= "Default message";

Dies ermöglicht es einer Methode, einen Standardwert zuzuweisen, anstatt zu werfen, falls gewünscht.

Bedeutung der Null-Prüfung bei der Fehlerbehandlung

Tim erinnert Entwickler daran, dass auch wenn C# jetzt nullbare Referenztypen unterstützt, Laufzeit-Nullprüfungen immer noch unerlässlich sind. Der Compiler kann nicht jedes Null-Referenz-Problem erkennen - vor allem dann nicht, wenn die Daten aus externen Quellen oder Methoden außerhalb Ihrer Kontrolle stammen.

Er betont, dass es eine gute Praxis ist, die Argumente zu überprüfen und gegebenenfalls eine ArgumentNullException auszulösen, um sicherzustellen, dass die Methode nur ausgeführt wird, wenn die Eingaben gültig sind. Dadurch werden Laufzeitfehler minimiert, die Fehlerbehandlung vereinfacht und stillschweigende Ausfälle verhindert.

Abschluss und Ausblick

Abschließend merkt Tim an, dass C# 11 noch mehr Verbesserungen einführen wird, aber im Moment ist ArgumentNullException.ThrowIfNull() eine der besten kleinen Verbesserungen für die Fehlerbehandlung und Codesicherheit in .NET 6.

Er ermutigt Entwickler, diesen Ansatz in ihren eigenen Projekten auszuprobieren und zu sehen, wie viel sauberer ihre Methoden aussehen. Er endet mit einer Frage: "Was denken Sie über diese Änderung in C# 10?"

Abschließende Gedanken

Tim Coreys Video macht deutlich, dass die Methode ArgumentNullException.ThrowIfNull() eine einfache, aber leistungsstarke Verbesserung in C# 10 ist. Sie reduziert fehleranfälligen manuellen Code, stellt gültige Argumente sicher und sorgt dafür, dass Ihre Programme schnell fehlschlagen, wenn ein Null-Argument übergeben wird.

Durch die konsequente Anwendung dieser Methode können Entwickler robusten, lesbaren und wartbaren Code erstellen, der Ausnahmen sauber behandelt und subtile Null-Referenz-Fehler vermeidet.

Kurz gesagt, wann immer Ihre Methode einen gültigen Parameter erwartet und Sie Null-Argumente verhindern wollen, folgen Sie dem Beispiel von Tim Corey und verwenden Sie:

ArgumentNullException.ThrowIfNull(parameterName);

ArgumentNullException.ThrowIfNull(parameterName);

Es ist eine sauberere, sicherere und modernere Methode, um Ihren Code vor Nullwerten und Laufzeitfehlern in .NET 6 und darüber hinaus zu schützen.