C# Nullable Types (Wie es für Entwickler funktioniert)

Beim Arbeiten mit C# müssen Sie oft null-Werte verarbeiten, insbesondere bei Referenztypen. Nullable Typen in C# bieten eine Möglichkeit, undefinierte oder fehlende Werte für Werttypen darzustellen. Dieser Leitfaden behandelt die Grundlagen der C# Nullable Typen, ihre praktischen Anwendungen und deren Funktionsweise in verschiedenen Szenarien. Im weiteren Verlauf des Artikels werden wir auch den IronPDF erkunden.

Nullbare Typen in C##

Standardmäßig können Werttypen in C# (z. B. int, bool, DateTime) keine Nullwerte zugewiesen werden. Um diese Einschränkung zu beheben, führt C# Nullable-Werttypen ein, die es Ihnen ermöglichen, Value-Typen null zuzuweisen. Nullable-Typen sind besonders nützlich, wenn Sie das Fehlen eines gültigen Werts darstellen müssen.

Nullbare Typen deklarieren

Um einen nullbaren Typ in C# zu deklarieren, verwenden Sie die folgende Syntax:

// Nullable type variable value
int? nullableInt = null;

// Nullable type variable value
int? nullableInt = null;

' Nullable type variable value
Dim nullableInt? As Integer = Nothing

Hier wird int? ist eine Kurzform für Nullable. Die Variable nullableInt kann entweder einen int-Wert oder null enthalten.

Prüfen auf Null

Um zu prüfen, ob eine Variable vom Typ nullable einen Wert hat oder nicht, können Sie die Eigenschaft HasValue verwenden oder die Variable direkt mit null vergleichen. Zum Beispiel:

if (nullableInt.HasValue)
{
    Console.WriteLine("Value: " + nullableInt.Value);
}
else
{
    Console.WriteLine("No value assigned.");
}

if (nullableInt.HasValue)
{
    Console.WriteLine("Value: " + nullableInt.Value);
}
else
{
    Console.WriteLine("No value assigned.");
}

If nullableInt.HasValue Then
	Console.WriteLine("Value: " & nullableInt.Value)
Else
	Console.WriteLine("No value assigned.")
End If

Alternativ können Sie den Null-Koaleszenz-Operator (??) verwenden, um einen Standardwert bereitzustellen, wenn der Nullable-Typ null ist:

int result = nullableInt ?? 0;
Console.WriteLine("Result: " + result);

int result = nullableInt ?? 0;
Console.WriteLine("Result: " + result);

Dim result As Integer = If(nullableInt, 0)
Console.WriteLine("Result: " & result)

Wenn nullableInt null ist, wird dem Ergebnis der Standardwert 0 zugewiesen.

Nullbare Werttypen vs. Nullbare Referenztypen

In C# unterscheiden sich Werttypen (wie int, bool und double) von Referenztypen (wie string, object). Nullable value types erlauben es Werttypen, Null darzustellen, während nullable reference types es erlauben, dass Referenztypen standardmäßig nicht nullbar sind, wodurch das Risiko von Nullreferenzausnahmen reduziert wird.

Nullbare Werttypen

Ein nullable value type erlaubt es einem Wertetyp, einen Nullwert anzunehmen. Um einen nullbaren Werttyp zu deklarieren, fügen Sie ein Fragezeichen ? zum Datentyp:

double? nullableDouble = null;

double? nullableDouble = null;

Dim nullableDouble? As Double = Nothing

In diesem Beispiel kann nullableDouble einen Double-Wert oder Null enthalten.

Nullbare Referenztypen

Nullbare Referenztypen wurden in C# 8.0 eingeführt. Sie aktivieren löschbare Referenztypen auf Projektebene oder indem Sie die Direktive #nullable enable am Anfang Ihrer Codedatei hinzufügen. Bei aktivierten löschbaren Referenztypen müssen Referenztypen explizit mit ? als löschbar markiert werden, was dazu beiträgt, potenzielle Laufzeitausnahmen zu vermeiden, die durch Null-Referenzen verursacht werden.

#nullable enable
string? nullableString = null;

#nullable enable
string? nullableString = null;

'INSTANT VB TODO TASK: There is no equivalent to #nullable in VB:
'#nullable enable
'INSTANT VB WARNING: Nullable reference types have no equivalent in VB:
'ORIGINAL LINE: string? nullableString = null;
Dim nullableString As String = Nothing

Hier darf nullableString null sein. Wenn Sie einen nicht-nullbaren Referenztyp ohne das ? deklarieren, wird der Compiler Warnungen ausgeben, wenn er potenzielle Null-Zuweisungen erkennt.

Aktivieren von nullbaren Referenztypen

Um nullbare Referenztypen global in einem Projekt zu aktivieren, fügen Sie die folgende Zeile zu Ihrer .csproj-Datei hinzu:

<Nullable>enable</Nullable>

<Nullable>enable</Nullable>

Sobald diese Option aktiviert ist, behandelt der Compiler Referenztypen standardmäßig als nicht-nullbar. Diese Funktion ist besonders praktisch, um Null-Referenz-Probleme zur Kompilierzeit und nicht zur Laufzeit zu erkennen.

Praktische Beispiele

Lassen Sie uns einige praktische Beispiele untersuchen, um Ihr Verständnis von nullable types zu festigen.

Beispiel 1: Nullable Type mit Value Types

In diesem Beispiel verwenden wir einen nullbaren Typ mit int:

class Program
{
    static void Main(string[] args)
    {
        int? nullableInt = null;
        int b = nullableInt ?? 10; // Use null coalescing operator
        Console.WriteLine("b: " + b);
        if (nullableInt.HasValue)
        {
            Console.WriteLine("nullableInt has value: " + nullableInt.Value);
        }
        else
        {
            Console.WriteLine("nullableInt is null");
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        int? nullableInt = null;
        int b = nullableInt ?? 10; // Use null coalescing operator
        Console.WriteLine("b: " + b);
        if (nullableInt.HasValue)
        {
            Console.WriteLine("nullableInt has value: " + nullableInt.Value);
        }
        else
        {
            Console.WriteLine("nullableInt is null");
        }
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim nullableInt? As Integer = Nothing
		Dim b As Integer = If(nullableInt, 10) ' Use null coalescing operator
		Console.WriteLine("b: " & b)
		If nullableInt.HasValue Then
			Console.WriteLine("nullableInt has value: " & nullableInt.Value)
		Else
			Console.WriteLine("nullableInt is null")
		End If
	End Sub
End Class

Hier ist nullableInt eine Variable vom Typ int, die gelöscht werden kann. Wenn nullableInt null ist, erhält b aufgrund des Null-Coalescing-Operators den Wert 10. Andernfalls nimmt b den Wert von nullableInt an.

Beispiel 2: Nullbare Referenztypen

Schauen wir uns nun an, wie nullbare Referenztypen funktionieren:

#nullable enable
class Program
{
    static void Main()
    {
        string? nullableString = null;
        string nonNullableString = "Hello";
        Console.WriteLine(nullableString?.Length ?? 0); // Use null coalescing operator
        Console.WriteLine(nonNullableString.Length);
    }
}

#nullable enable
class Program
{
    static void Main()
    {
        string? nullableString = null;
        string nonNullableString = "Hello";
        Console.WriteLine(nullableString?.Length ?? 0); // Use null coalescing operator
        Console.WriteLine(nonNullableString.Length);
    }
}

'INSTANT VB TODO TASK: There is no equivalent to #nullable in VB:
'#nullable enable
Friend Class Program
	Shared Sub Main()
'INSTANT VB WARNING: Nullable reference types have no equivalent in VB:
'ORIGINAL LINE: string? nullableString = null;
		Dim nullableString As String = Nothing
		Dim nonNullableString As String = "Hello"
		Console.WriteLine(If(nullableString?.Length, 0)) ' Use null coalescing operator
		Console.WriteLine(nonNullableString.Length)
	End Sub
End Class

Im obigen Code kann nullableString null sein, und der Null-Coalescing-Operator stellt sicher, dass die Länge der Zeichenfolge standardmäßig 0 ist, wenn sie null ist.

Beispiel 3: Verschachtelte nullbare Typen

In C# können Sie verschachtelte nullbare Typen deklarieren. Zum Beispiel:

int?? nestedNullableInt = null;

int?? nestedNullableInt = null;

If(Integer, nestedNullableInt) = Nothing

Verschachtelte nullbare Typen mögen zwar redundant erscheinen, sind aber in C# syntaktisch gültig. In der Praxis bieten verschachtelte nullbare Typen jedoch keine zusätzlichen Funktionen und werden nur selten verwendet.

Null-Koaleszenz-Operator (??)

Der null-koaleszierende Operator (??) wird häufig mit Nullable-Typen verwendet, um einen Standardwert bereitzustellen, wenn der Nullable-Typ null ist. Dieser Operator vereinfacht den Code, indem er explizite if-else-Prüfungen vermeidet.

int? nullableValue = null;
int defaultValue = nullableValue ?? -1;

int? nullableValue = null;
int defaultValue = nullableValue ?? -1;

Dim nullableValue? As Integer = Nothing
Dim defaultValue As Integer = If(nullableValue, -1)

Wenn nullableValue in diesem Beispiel null ist, wird defaultValue der Wert -1 zugewiesen. Andernfalls nimmt defaultValue den Wert von nullableValue an.

Kompilierzeitfehler und nullbare Typen

Wenn nullbare Referenztypen aktiviert sind, erzeugt C# während der Kompilierung Warnungen und Fehler, wenn es potenzielle Probleme mit Null-Zuweisungen erkennt. Diese Kompilierzeitfehler helfen, Probleme frühzeitig zu erkennen und machen Ihren Code robuster.

Betrachten Sie das folgende Beispiel:

string? nullableString = null;
string nonNullableString = nullableString; // Compiler warning

string? nullableString = null;
string nonNullableString = nullableString; // Compiler warning

'INSTANT VB WARNING: Nullable reference types have no equivalent in VB:
'ORIGINAL LINE: string? nullableString = null;
Dim nullableString As String = Nothing
Dim nonNullableString As String = nullableString ' Compiler warning

In diesem Fall führt die Zuweisung von nullableString an nonNullableString zu einer Compilerwarnung, da nullableString null sein kann und die Zuweisung an einen nicht-nullable-Typ zu Laufzeitausnahmen führen kann.

Verwendung von nullbaren Typen mit IronPDF

IronPDF ist eine C# PDF-Bibliothek, die Entwicklern dabei hilft, PDF-Dateien direkt aus .NET-Anwendungen zu erstellen, zu bearbeiten und zu manipulieren. Sie können HTML in PDF umwandeln, Berichte erstellen oder sogar komplexe Dokumentstrukturen verarbeiten.

Nullable-Typen sind vor allem in dynamischen Berichtserstellungsszenarien nützlich, z. B. wenn Sie eine PDF-Datei für einen Buchhalter mit unvollständigen Finanzdaten erstellen. Durch die Verwendung von löschbaren Typen können Sie optionale Felder verwalten, Ausnahmen vermeiden und Standardwerte bereitstellen

using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        int? optionalIncome = null;  // Nullable type
        string? clientName = "Iron Dev";  // Nullable reference type
        var renderer = new ChromePdfRenderer();
        string htmlContent = $@"
            <h1>Financial Report</h1>
            <p>Client Name: {clientName ?? "Unknown"}</p>
            <p>Income: {optionalIncome?.ToString() ?? "Data not available"}</p>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("FinancialReport.pdf");
        Console.WriteLine("PDF Generated Successfully.");
    }
}

using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        int? optionalIncome = null;  // Nullable type
        string? clientName = "Iron Dev";  // Nullable reference type
        var renderer = new ChromePdfRenderer();
        string htmlContent = $@"
            <h1>Financial Report</h1>
            <p>Client Name: {clientName ?? "Unknown"}</p>
            <p>Income: {optionalIncome?.ToString() ?? "Data not available"}</p>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("FinancialReport.pdf");
        Console.WriteLine("PDF Generated Successfully.");
    }
}

Imports IronPdf
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim optionalIncome? As Integer = Nothing ' Nullable type
'INSTANT VB WARNING: Nullable reference types have no equivalent in VB:
'ORIGINAL LINE: string? clientName = "Iron Dev";
		Dim clientName As String = "Iron Dev" ' Nullable reference type
		Dim renderer = New ChromePdfRenderer()
		Dim htmlContent As String = $"
            <h1>Financial Report</h1>
            <p>Client Name: {If(clientName, "Unknown")}</p>ignoreignore<p>Income: {If(optionalIncome?.ToString(), "Data not available")}</p>"
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
		pdf.SaveAs("FinancialReport.pdf")
		Console.WriteLine("PDF Generated Successfully.")
	End Sub
End Class

In diesem Code sind Nullable-Typen (int? und string?) werden verwendet, um fehlende Daten sicher zu handhaben. Der Null-Koaleszenz-Operator (??) stellt sicher, dass, wenn Daten fehlen, ein Standardwert im PDF verwendet wird.

Schlussfolgerung

Nullable-Typen in C# sind ein leistungsfähiges Werkzeug für den Umgang mit Nullwerten in Werttypen und Referenztypen. Durch die Verwendung von nullable types können Sie null reference exceptions vermeiden und die Robustheit Ihres Codes verbessern. Denken Sie daran, in neuen Projekten Nullable-Referenztypen zu aktivieren, um von der Überprüfung auf Kompilierungsfehler zu profitieren, und verwenden Sie den Null-Koaleszenz-Operator (??), um Ihren Code beim Umgang mit Nullable-Typen zu vereinfachen.

IronPDF bietet eine kostenlose Testversion an, damit Sie seine Funktionen erkunden können, bevor Sie sich verpflichten. Sie können das Projekt kostenlos testen und sehen, wie es sich in Ihren Entwicklungsprozess einfügt. Sobald Sie bereit sind, voranzukommen, beginnen die Lizenzen ab $749.