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

Wenn Sie mit C# arbeiten, müssen Sie oft mit folgenden Dingen umgehennullwerteinsbesondere bei Referenztypen. Nullable-Typen in C# bieten eine Möglichkeit, undefinierte oder fehlende Werte für Wertetypen darzustellen. Dieser Leitfaden behandelt die Grundlagen von nullable types in C#, ihre praktische Verwendung und wie sie in verschiedenen Szenarien funktionieren. Wir erforschen dieIronPDF wie auch später im Artikel.

Nullbare Typen in C##

Standardmäßig sind Wertetypen in C#(z. B. int, bool, DateTime) können keine Nullwerte zugewiesen werden. Um dieser Einschränkung entgegenzuwirken, führt C# nullable value types ein, die es Ihnen ermöglichen, Werttypen den Wert null zuzuweisen. Nullable-Typen sind besonders nützlich, wenn Sie das Fehlen eines gültigen Wertes 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 die 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 auch 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# sind Wertetypen(wie z. B. int, bool und double) sich von Referenztypen unterscheiden(wie String, Objekt). 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>

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'<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-Koaleszenz-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, mit der Entwickler PDF-Dateien direkt aus .NET-Anwendungen erstellen, bearbeiten und manipulieren können. Sie könnenhTML in PDF konvertierensie sollen Berichte erstellen oder auch komplexe Dokumentstrukturen bearbeiten.

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 werden nullbare Typen(int? und String?) werden verwendet, um fehlende Daten sicher zu behandeln. Der Null-Koaleszenz-Operator(??) sorgt dafür, dass bei fehlenden Daten ein Standardwert in der PDF-Datei 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 nullbare Referenztypen zu aktivieren, um von der Fehlerprüfung bei der Kompilierung zu profitieren, und verwenden Sie den null coalescing operator(??) um Ihren Code zu vereinfachen, wenn Sie mit nullbaren Typen arbeiten.

IronPDF bietet einekostenloser Test um Ihnen zu helfen, die Funktionen zu erkunden, bevor Sie sich entscheiden. Sie können das Projekt kostenlos testen und sehen, wie es sich in Ihren Entwicklungsprozess einfügt. Sobald Sie bereit sind, fortzufahren, beginnen die Lizenzen bei $749.