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.

Nullbare Typen 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;
$vbLabelText   $csharpLabel

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

Prüfung auf Null

Um zu überprüfen, ob eine Variable eines Nullable Typs 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.");
}
$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);
$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, fügen Sie ein Fragezeichen ? zum Datentyp hinzu:

// Declare a nullable double
double? nullableDouble = null;
// Declare a nullable double
double? nullableDouble = null;
$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 indem Sie die Direktive #nullable enable am Anfang Ihrer Code-Datei hinzufügen. Mit aktivierten Nullable Referenztypen müssen Referenztypen explizit als nullfähig mit ? markiert werden, um potenzielle Laufzeitausnahmen durch Nullreferenzen zu vermeiden.

#nullable enable
// Declare a nullable string
string? nullableString = null;
#nullable enable
// Declare a nullable string
string? nullableString = null;
$vbLabelText   $csharpLabel

Hier darf nullableString null sein. Wenn Sie einen nicht-nullfähigen Referenztyp ohne ? deklarieren, erzeugt der Compiler Warnungen, wenn er potenzielle null-Zuweisungen erkennt.

Nullbare Referenztypen aktivieren

Um Nullable Referenztypen 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");
        }
    }
}
$vbLabelText   $csharpLabel

Hier ist nullableInt eine nullable Typvariable von int. Wenn nullableInt null ist, erhält b den Wert 10 aufgrund des Null-Koaleszenz-Operators. 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);
    }
}
$vbLabelText   $csharpLabel

Im 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 standardisiert wird.

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;
$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;
$vbLabelText   $csharpLabel

In diesem Beispiel wird defaultValue auf -1 gesetzt, wenn nullableValue null ist. Andernfalls nimmt defaultValue den Wert von nullableValue an.

Compile-Time-Fehler 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.

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;
string? nullableString = null;
// This will produce a compiler warning because nullableString may be null
string nonNullableString = nullableString;
$vbLabelText   $csharpLabel

In diesem Fall erzeugt das Zuweisen von nullableString an nonNullableString eine Compilerwarnung, da nullableString null sein könnte, und es in einen nicht-nullfähigen Typ zuzuweisen, könnte zu Laufzeitausnahmen führen.

Verwendung von nullbaren Typen mit IronPDF

C# Nullable Typen (Wie es für Entwickler funktioniert): 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.");
    }
}
$vbLabelText   $csharpLabel

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

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

Abschluss

C# Nullable Typen (Wie es für Entwickler funktioniert): Abbildung 3 - IronPDF-Lizenzierungsseite

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 $799.

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 führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

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