Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. C# Nullable-Typen
.NET HILFE

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

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

Beim Arbeiten mit C# müssen Sie häufig null-Werte behandeln, besonders bei Referenztypen. Nullable Typen in C# bieten eine Möglichkeit, nicht definierte oder nicht vorhandene Werte für Werttypen darzustellen. Diese Anleitung behandelt die Grundlagen von C# Nullable Typen, ihre praktischen Anwendungen und wie sie in verschiedenen Szenarien funktionieren. Wir werden später im Artikel auch das IronPDF erkunden.

Nullable Types in C

Standardmäßig können Werttypen in C# (z.B. int, bool, DateTime) keine null-Werte zugewiesen werden. Um diese Einschränkung zu adressieren, führt C# nullable Werttypen ein, sodass Sie null an Werttypen zuweisen können. Nullable Typen sind besonders nützlich, wenn Sie das Fehlen eines gültigen Werts darstellen müssen.

Nullbare Typen deklarieren

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

// Declare a nullable integer
int? nullableInt = null;
// Declare a nullable integer
int? nullableInt = null;
' Declare a nullable integer
Dim nullableInt? As Integer = Nothing
$vbLabelText   $csharpLabel

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

Prüfung 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, wie unten gezeigt:

if (nullableInt.HasValue)
{
    // If nullableInt has a value, print it
    Console.WriteLine("Value: " + nullableInt.Value);
}
else
{
    // If nullableInt does not have a value, print a message
    Console.WriteLine("No value assigned.");
}
if (nullableInt.HasValue)
{
    // If nullableInt has a value, print it
    Console.WriteLine("Value: " + nullableInt.Value);
}
else
{
    // If nullableInt does not have a value, print a message
    Console.WriteLine("No value assigned.");
}
If nullableInt.HasValue Then
	' If nullableInt has a value, print it
	Console.WriteLine("Value: " & nullableInt.Value)
Else
	' If nullableInt does not have a value, print a message
	Console.WriteLine("No value assigned.")
End If
$vbLabelText   $csharpLabel

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

// Assign 0 if nullableInt is null
int result = nullableInt ?? 0;
Console.WriteLine("Result: " + result);
// Assign 0 if nullableInt is null
int result = nullableInt ?? 0;
Console.WriteLine("Result: " + result);
' Assign 0 if nullableInt is null
Dim result As Integer = If(nullableInt, 0)
Console.WriteLine("Result: " & result)
$vbLabelText   $csharpLabel

Wenn nullableInt null ist, wird result 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 Werttypen ermöglichen es, dass Werttypen null darstellen können, während Nullable Referenztypen es ermöglichen, dass Referenztypen standardmäßig nicht nullable sind, wodurch das Risiko von Nullreferenzausnahmen reduziert wird.

Nullbare Wertetypen

Ein Nullable Werttyp erlaubt es, dass ein Werttyp einen null-Wert annimmt. Um einen Nullable-Werttyp zu deklarieren, hängen Sie ein Fragezeichen ? an den Datentyp an:

// Declare a nullable double
double? nullableDouble = null;
// Declare a nullable double
double? nullableDouble = null;
' Declare a nullable double
Dim nullableDouble? As Double = Nothing
$vbLabelText   $csharpLabel

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

Nullbare Referenztypen

Nullable Referenztypen wurden in C# 8.0 eingeführt. Sie können nullable Referenztypen auf Projektebene aktivieren oder die Direktive #nullable enable am Anfang Ihrer Codedatei hinzufügen. Sind nullable Referenztypen aktiviert, müssen Referenztypen explizit mit ? als nullable gekennzeichnet werden. Dies hilft, potenzielle Laufzeitausnahmen durch Nullreferenzen zu vermeiden.

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

Hier darf nullableString null sein. Wenn Sie einen nicht-nullbaren Referenztyp ohne ? deklarieren, gibt der Compiler Warnungen aus, wenn er potenzielle Nullzuweisungen erkennt.

Nullbare Referenztypen aktivieren

Um Nullable Reference Types global in einem Projekt zu aktivieren, fügen Sie die folgende Zeile zu Ihrer .csproj Datei hinzu:

<Nullable>enable</Nullable>
<Nullable>enable</Nullable>
XML

Einmal aktiviert, behandelt der Compiler Referenztypen standardmäßig als nicht-nullfähig. Dieses Feature ist besonders praktisch, um Nullreferenzprobleme zur Kompilierzeit statt zur Laufzeit zu erkennen.

Praktische Beispiele

Lassen Sie uns einige praktische Beispiele erkunden, um Ihr Verständnis von Nullable Typen zu vertiefen.

Beispiel 1: Nullable Type mit Value Types

In diesem Beispiel werden wir einen Nullable Typ mit int verwenden:

class Program
{
    static void Main(string[] args)
    {
        int? nullableInt = null;
        // Use null coalescing operator to assign a default value
        int b = nullableInt ?? 10;
        Console.WriteLine("b: " + b);
        if (nullableInt.HasValue)
        {
            // nullableInt has a value
            Console.WriteLine("nullableInt has value: " + nullableInt.Value);
        }
        else
        {
            // nullableInt is null
            Console.WriteLine("nullableInt is null");
        }
    }
}
class Program
{
    static void Main(string[] args)
    {
        int? nullableInt = null;
        // Use null coalescing operator to assign a default value
        int b = nullableInt ?? 10;
        Console.WriteLine("b: " + b);
        if (nullableInt.HasValue)
        {
            // nullableInt has a value
            Console.WriteLine("nullableInt has value: " + nullableInt.Value);
        }
        else
        {
            // nullableInt is null
            Console.WriteLine("nullableInt is null");
        }
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim nullableInt? As Integer = Nothing
		' Use null coalescing operator to assign a default value
		Dim b As Integer = If(nullableInt, 10)
		Console.WriteLine("b: " & b)
		If nullableInt.HasValue Then
			' nullableInt has a value
			Console.WriteLine("nullableInt has value: " & nullableInt.Value)
		Else
			' nullableInt is null
			Console.WriteLine("nullableInt is null")
		End If
	End Sub
End Class
$vbLabelText   $csharpLabel

Hierbei handelt es sich bei nullableInt um eine Variable vom Typ int, die Nullwerte zulässt. Wenn nullableInt null ist, erhält b aufgrund des Null-Koaleszenzoperators den Wert 10. Andernfalls nimmt b den Wert von nullableInt an.

Beispiel 2: Nullbare Referenztypen

Schauen wir uns nun an, wie Nullable Referenztypen funktionieren:

#nullable enable
class Program
{
    static void Main()
    {
        string? nullableString = null;
        string nonNullableString = "Hello";
        // Use null coalescing operator to provide a default value for length
        Console.WriteLine(nullableString?.Length ?? 0);
        Console.WriteLine(nonNullableString.Length);
    }
}
#nullable enable
class Program
{
    static void Main()
    {
        string? nullableString = null;
        string nonNullableString = "Hello";
        // Use null coalescing operator to provide a default value for length
        Console.WriteLine(nullableString?.Length ?? 0);
        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"
		' Use null coalescing operator to provide a default value for length
		Console.WriteLine(If(nullableString?.Length, 0))
		Console.WriteLine(nonNullableString.Length)
	End Sub
End Class
$vbLabelText   $csharpLabel

Im obigen Code kann nullableString null sein, und der Null-Koaleszenzoperator stellt sicher, dass die Länge der Zeichenkette standardmäßig auf 0 gesetzt wird, wenn es null ist.

Beispiel 3: Verschachtelte nullbare Typen

C# erlaubt Ihnen, verschachtelte Nullable Typen zu deklarieren. Zum Beispiel:

// Redundant, but syntactically valid
int? nestedNullableInt = null;
// Redundant, but syntactically valid
int? nestedNullableInt = null;
' Redundant, but syntactically valid
Dim nestedNullableInt? As Integer = Nothing
$vbLabelText   $csharpLabel

Obwohl verschachtelte Nullable Typen redundant erscheinen mögen, sind sie in C# syntaktisch gültig. In der Praxis bieten verschachtelte Nullable Typen jedoch keine zusätzliche Funktionalität und werden 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-Überprüfungen vermeidet.

int? nullableValue = null;
// Assign -1 if nullableValue is null
int defaultValue = nullableValue ?? -1;
int? nullableValue = null;
// Assign -1 if nullableValue is null
int defaultValue = nullableValue ?? -1;
Dim nullableValue? As Integer = Nothing
' Assign -1 if nullableValue is null
Dim defaultValue As Integer = If(nullableValue, -1)
$vbLabelText   $csharpLabel

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

Kompilierfehler und nullbare Typen

Mit aktivierten Nullable Referenztypen erzeugt C# Warnungen und Fehler während der Kompilierung, wenn es potenzielle Probleme mit null-Zuweisungen erkennt. Diese Kompilierfehler helfen, Probleme frühzeitig zu erkennen und machen Ihren Code robuster.

Betrachten Sie folgendes Beispiel:

string? nullableString = null;
// This will produce a compiler warning because nullableString may be null
string nonNullableString = nullableString;
string? nullableString = null;
// This will produce a compiler warning because nullableString may be null
string nonNullableString = nullableString;
'INSTANT VB WARNING: Nullable reference types have no equivalent in VB:
'ORIGINAL LINE: string? nullableString = null;
Dim nullableString As String = Nothing
' This will produce a compiler warning because nullableString may be null
Dim nonNullableString As String = nullableString
$vbLabelText   $csharpLabel

In diesem Fall führt die Zuweisung von nullableString zu nonNullableString zu einer Compilerwarnung, da nullableString null sein kann und die Zuweisung zu einem nicht nullbaren Typ zu Laufzeitausnahmen führen könnte.

Verwendung von nullbaren Typen mit IronPDF

C# Nullable Types (So funktioniert es für Entwickler): Abbildung 1 - IronPDF: C# PDF-Bibliothek

IronPDF ist eine C# PDF Bibliothek, die entwickelt wurde, um Entwicklern zu helfen, PDF-Dateien direkt aus .NET-Anwendungen zu erstellen, zu bearbeiten und zu manipulieren. Sie können HTML in PDF konvertieren, Berichte generieren oder sogar komplexe Dokumentstrukturen bearbeiten.

Nullable Typen sind besonders nützlich in Szenarien der dynamischen Berichterstellung, wie z.B. wenn Sie ein PDF für einen Buchhalter mit unvollständigen Finanzdaten erstellen. Durch die Verwendung von Nullable 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 for optional income
        string? clientName = "Iron Dev";  // Nullable reference type for client name
        var renderer = new ChromePdfRenderer();
        string htmlContent = $@"
            <h1>Financial Report</h1>
            <p>Client Name: {clientName ?? "Unknown"}</p>
            <p>Income: {optionalIncome?.ToString() ?? "Data not available"}</p>";
        // Render the HTML to a PDF
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF to disk
        pdf.SaveAs("FinancialReport.pdf");
        Console.WriteLine("PDF Generated Successfully.");
    }
}
using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        int? optionalIncome = null;  // Nullable type for optional income
        string? clientName = "Iron Dev";  // Nullable reference type for client name
        var renderer = new ChromePdfRenderer();
        string htmlContent = $@"
            <h1>Financial Report</h1>
            <p>Client Name: {clientName ?? "Unknown"}</p>
            <p>Income: {optionalIncome?.ToString() ?? "Data not available"}</p>";
        // Render the HTML to a PDF
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF to disk
        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 for optional income
'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 for client name
		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>"
		' Render the HTML to a PDF
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
		' Save the PDF to disk
		pdf.SaveAs("FinancialReport.pdf")
		Console.WriteLine("PDF Generated Successfully.")
	End Sub
End Class
$vbLabelText   $csharpLabel

C# Nullable Types (So funktioniert es für Entwickler): Abbildung 2 - Beispielcodeausgabe

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

Abschluss

C# Nullable Types (So funktioniert es für Entwickler): Abbildung 3 - IronPDF -Lizenzseite

Nullable Typen in C# sind ein mächtiges Werkzeug zur Handhabung von Nullwerten in sowohl Wert- als auch Referenztypen. Durch die Verwendung von Nullable Typen können Sie Nullreferenzausnahmen vermeiden und die Robustheit Ihres Codes verbessern. Denken Sie daran, Nullable Referenztypen in neuen Projekten zu aktivieren, um von der Fehlerüberprüfung zur Kompilierzeit zu profitieren, und verwenden Sie den Null-Koaleszenz-Operator (??), um Ihren Code beim Umgang mit Nullable Typen zu vereinfachen.

IronPDF bietet eine kostenlose Testversion, um Ihnen zu helfen, seine Funktionen zu erkunden, bevor Sie sich verpflichten. Ohne vorab anfallende Kosten können Sie es testen und sehen, wie es in Ihren Entwicklungsprozess passt. Sobald Sie bereit sind, fortzufahren, beginnen die Lizenzen bei $999.

Häufig gestellte Fragen

Wie können nullable Typen bei der dynamischen PDF-Erstellung genutzt werden?

Nullable Typen können bei der dynamischen PDF-Erstellung entscheidend sein, indem sie es ermöglichen, optionale Felder sicher darzustellen, unter Verwendung von Bibliotheken wie IronPDF. Dies stellt sicher, dass fehlende Daten angemessen behandelt werden, wobei erforderlichenfalls Standardwerte bereitgestellt werden.

Wie sieht die Syntax zur Deklaration von Nullable-Typen in C# aus?

In C# können Sie einen Nullable-Typ deklarieren, indem Sie ein Fragezeichen '?' an den Datentyp anhängen. Um beispielsweise einen Nullable-Integer zu deklarieren, würden Sie int? nullableInt = null; schreiben.

Können Nullable-Typen in C# die Robustheit von generierten Berichten beeinflussen?

Ja, die Verwendung von Nullable-Typen kann die Robustheit von generierten Berichten erhöhen, indem sichergestellt wird, dass optionale Felder keine Fehler verursachen, wenn ihre Werte fehlen. Bibliotheken wie IronPDF können Nullable-Typen nutzen, um diese Bedingungen effizient zu verwalten.

Wie helfen nullable Referenztypen, Laufzeitfehler zu verhindern?

Nullable Referenztypen, eingeführt in C# 8.0, helfen, Laufzeitfehler zu verhindern, indem Referenztypen standardmäßig nicht-nullable sind. Dies reduziert das Risiko von Nullverweis-Ausnahmen und ermöglicht eine frühzeitige Erkennung potenzieller Probleme während der Kompilierung.

Welche Rolle spielt der Null-Koaleszenz-Operator bei der Verwaltung von Nullable-Typen?

Der Null-Koaleszenz-Operator ?? wird zur Verwaltung von Nullable-Typen verwendet, indem er einen Standardwert bereitstellt, wenn ein Nullable-Typ null ist. Er vereinfacht den Code und hilft, explizite If-Else-Prüfungen zu vermeiden.

Wie kann geprüft werden, ob ein Nullable-Typ in C# einen Wert hat?

Sie können feststellen, ob ein Nullable-Typ in C# einen Wert hat, indem Sie die HasValue-Eigenschaft verwenden oder die Variable direkt mit null vergleichen.

Was sind einige typische Szenarien für die Verwendung von Nullable-Typen in C#-Anwendungen?

Nullable-Typen werden oft in Situationen verwendet, in denen Daten unvollständig oder optional sein können, wie beispielsweise bei Formulareingaben, Konfigurationseinstellungen oder beim Umgang mit Datenbanken, die Nullwerte erlauben. Sie sind besonders nützlich bei der dynamischen Berichtserstellung mit Bibliotheken wie IronPDF.

Wie beeinflusst das Aktivieren von Nullable-Referenztypen die C#-Projekterstellung?

Die Aktivierung von nullable Referenztypen in einem C#-Projekt führt zu Kompilierungswarnungen und -fehlern aufgrund potenzieller Nullreferenzprobleme, wodurch Probleme frühzeitig erkannt werden und die Entwicklung robusterer Codes gefördert wird.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an