Nullable-Referenztypen (Bewusstsein) und Annotations (C#-6-Muster)
C# 6 kennt keine Nullable-Referenztypen (string?). Lernen Sie den sicheren Umgang mit null: Eingabeprüfungen, klare Dokumentation, den Helfer Require.NotNull und den Vergleich mit Nullable für Werttypen.
Nullable-Referenztypen (Bewusstsein) und Annotations (C#-6-Muster) ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 3. 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 3 Lektionen.
NRT-Bewusstsein & Fallback
Idee: Nullable-Referenztypen (z. B. string?) fügen in neueren C#-Versionen Compilerprüfungen hinzu.
- C# 6 unterstützt string? nicht.
- Verwenden Sie Guards, eine klare Dokumentation und einfache Hilfsmethoden.
- Geben Sie standardmäßig einen Nicht-Null-Wert zurück.
Gegen null absichern
Fügen Sie für Parameter von Referenztypen Guards mit ArgumentNullException hinzu; behandeln Sie die Werte anschließend als nicht null.
using System;
public static class Greeter
{
// Contract: name must not be null (C# 6 has no string? to enforce)
public static string Hello(string name)
{
if (name == null) throw new ArgumentNullException("name"); // guard
return "Hello " + name.ToUpper(); // safe after guard
}
}
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine(Greeter.Hello("Ada"));
try
{
Console.WriteLine(Greeter.Hello(null)); // will throw (by design)
}
catch (Exception ex)
{
Console.WriteLine("Caught: " + ex.GetType().Name);
}
}
}
Require.NotNull-Hilfsmethode
Erstellen Sie eine kleine Require.NotNull-Hilfsmethode, um wiederkehrenden Code zu reduzieren und die Absicht klar erkennbar zu machen.
using System;
public static class Require
{
// Works for reference types; returns the validated value
public static T NotNull<T>(T value, string name) where T : class
{
if (value == null) throw new ArgumentNullException(name);
return value;
}
}
public sealed class Email
{
public string Address { get; private set; }
public Email(string address)
{
Address = Require.NotNull(address, "address").Trim();
}
}
public class Program
{
public static void Main(string[] args)
{
Email e = new Email("user@mail.com");
Console.WriteLine(e.Address);
}
}
Nullable<T> im Vergleich zu Referenztypen
Nullable<T> (z. B. int?) ist für Werttypen gedacht. Referenztypen können bereits null sein; in C# 6 verwenden wir Guards.
using System;
public class Program
{
public static void Main(string[] args)
{
int x = 5; // value type (non-nullable)
int? maybe = null; // Nullable<T> works for value types
Console.WriteLine("x=" + x);
Console.WriteLine("maybe has value? " + maybe.HasValue);
Console.WriteLine("maybe or default: " + (maybe ?? -1));
}
}
Nullverträge dokumentieren
Geben Sie die Nullbarkeit in der XML-Dokumentation an und bleiben Sie konsistent: Entweder sind Werte immer nicht null, oder Sie dokumentieren klar, wann null möglich ist.
using System;
/// <summary>
/// Parses "key=value" and returns the value part.
/// Returns null if the format is invalid.
/// </summary>
public static class Parser
{
// Explicitly document when null can be returned.
public static string TryGetValue(string line)
{
if (line == null) throw new ArgumentNullException("line");
int idx = line.IndexOf("=");
if (idx < 0 || idx == line.Length - 1) return null; // documented nullable return
return line.Substring(idx + 1);
}
}
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine(Parser.TryGetValue("a=1"));
Console.WriteLine(Parser.TryGetValue("oops")); // prints nothing (null)
}
}
Checkliste für Null-Sicherheit (C# 6)
Checkliste:
- Sichern Sie Eingaben mit ArgumentNullException ab.
- Geben Sie standardmäßig einen Nicht-Null-Wert zurück; dokumentieren Sie alle Rückgabewerte, die null sein können.
- Verwenden Sie kleine Hilfsmethoden (Require.NotNull), damit der Code übersichtlich bleibt.
- Bevorzugen Sie, wenn sinnvoll, Überladungen, die null vermeiden (z. B. eine leere Zeichenfolge statt null).
Null-Sicherheit in C# 6
Zusammenfassung
Zusammenfassung: NRTs sind eine neuere Funktion. In C# 6 sorgen Sie mit Guards, einer klaren Dokumentation, Hilfsmethoden und vorhersehbaren Nicht-Null-Rückgabeverträgen für Sicherheit.
Häufig gestellte Fragen
Ist die Lektion „Nullable-Referenztypen (Bewusstsein) und Annotations (C#-6-Muster)“ kostenlos?
Ja — der vollständige Text von „Nullable-Referenztypen (Bewusstsein) und Annotations (C#-6-Muster)“ 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 3 Lektionen.
Was lerne ich in „Nullable-Referenztypen (Bewusstsein) und Annotations (C#-6-Muster)“?
C# 6 kennt keine Nullable-Referenztypen (string?). Lernen Sie den sicheren Umgang mit null: Eingabeprüfungen, klare Dokumentation, den Helfer Require.NotNull und den Vergleich mit Nullable für Wertty… 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 3.
Wie lange dauert die Lektion „Nullable-Referenztypen (Bewusstsein) und Annotations (C#-6-Muster)“?
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
- Generische Methoden/Typen und Einschränkungen
- Varianz (in/out) mit Interfaces und Delegates
- Nullable-Referenztypen (Bewusstsein) und Annotations (C#-6-Muster)