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.
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.
Um einen Nullable Typ in C# zu deklarieren, verwenden Sie die folgende Syntax:
// Declare a nullable integer
int? nullableInt = null;' Declare a nullable integer
Dim nullableInt? As Integer = NothingHier ist int? eine Abkürzung für Nullable<int>. Die Variable nullableInt kann entweder einen int-Wert oder null enthalten.
Um zu überprüfen, ob eine nullable Typvariable einen Wert hat oder nicht, können Sie die HasValue-Eigenschaft 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 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 IfAlternativ 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
Dim result As Integer = If(nullableInt, 0)
Console.WriteLine("Result: " & result)Wenn nullableInt null ist, wird result der Standardwert 0 zugewiesen.
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.
Ein Nullable Werttyp erlaubt es, dass ein Werttyp einen null-Wert annimmt. Um einen nullable Wertetyp zu deklarieren, fügen Sie ein Fragezeichen ? an den Datentyp an:
// Declare a nullable double
double? nullableDouble = null;' Declare a nullable double
Dim nullableDouble? As Double = NothingIn diesem Beispiel kann nullableDouble einen double-Wert oder null enthalten.
Nullfähige Referenztypen wurden in C# 8.0 eingeführt. Sie können nullfähige Referenztypen auf Projektebene aktivieren oder indem Sie die #nullable enable-Direktive am Anfang Ihrer Code-Datei hinzufügen. Mit aktivierten nullfähigen Referenztypen müssen Referenztypen explizit als nullable markiert werden, indem Sie ? verwenden, um potenzielle Laufzeitausnahmen durch null-Referenzen zu vermeiden.
#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 = NothingHier darf nullableString null sein. Wenn Sie einen nicht nullfähigen Referenztyp ohne das ? deklarieren, gibt der Compiler Warnungen aus, wenn er potenzielle null-Zuweisungen erkennt.
Um nullfähige Referenztypen global in einem Projekt zu aktivieren, fügen Sie die folgende Zeile in Ihre .csproj-Datei ein:
<Nullable>enable</Nullable>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.
Lassen Sie uns einige praktische Beispiele erkunden, um Ihr Verständnis von Nullable Typen zu vertiefen.
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");
}
}
}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 ClassHier ist nullableInt eine nullable Typvariable vom Typ int. Wenn nullableInt null ist, erhält b den Wert 10 durch den null-Koaleszenz-Operator. Andernfalls nimmt b den Wert von nullableInt an.
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);
}
}'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 ClassIm obigen Code kann nullableString null sein, und der null-Koaleszenz-Operator stellt sicher, dass, wenn es null ist, die Länge des Strings auf 0 gesetzt wird.
C# erlaubt Ihnen, verschachtelte Nullable Typen zu deklarieren. Zum Beispiel:
// Redundant, but syntactically valid
int? nestedNullableInt = null;' Redundant, but syntactically valid
Dim nestedNullableInt? As Integer = NothingObwohl 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.
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;Dim nullableValue? As Integer = Nothing
' Assign -1 if nullableValue is null
Dim defaultValue As Integer = If(nullableValue, -1)In diesem Beispiel, wenn nullableValue null ist, wird defaultValue -1 zugewiesen. Andernfalls nimmt defaultValue den Wert von nullableValue an.
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.
Beispiel: IronPDF rendert HTML zu einem PDF und speichert es.
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 = nullableStringIn diesem Fall erzeugt die Zuweisung von nullableString zu nonNullableString eine Compiler-Warnung, weil nullableString null sein könnte und die Zuweisung zu einem nicht nullfähigen Typ zu Laufzeitausnahmen führen könnte.
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.");
}
}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
In diesem Code werden nullable Typen (int? und string?) verwendet, um fehlende Daten sicher zu verarbeiten. Der null-coalescing Operator (??) stellt sicher, dass, wenn Daten fehlen, ein Standardwert im PDF verwendet wird.
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, weiterzumachen, beginnen Lizenzen ab $999.
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 Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
