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

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

Prüfung auf Null

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)
{
    // 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-Wertetyp zu deklarieren, fügen Sie ein Fragezeichen ? an den Datentyp an:

// 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 halten.

Nullbare Referenztypen

Nullable Referenztypen wurden in C# 8.0 eingeführt. Sie können nullable Referenztypen auf Projektebene aktivieren oder durch Hinzufügen der #nullable enable Direktive am Anfang Ihrer Code-Datei. Mit aktivierten Nullable-Referenztypen müssen Referenztypen ausdrücklich als nullable mit ? gekennzeichnet werden, um mögliche 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-nullbaren Referenztyp ohne ? deklarieren, wird der Compiler Warnungen erzeugen, wenn er mögliche Nullzuweisungen erkennt.

Nullbare Referenztypen aktivieren

Um nullable Referenztypen global in einem Projekt zu aktivieren, fügen Sie die folgende Zeile in Ihre .csproj Datei ein:

<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, bekommt b den Wert 10 wegen des Null-Coalescing-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-Coalescing-Operator stellt sicher, dass, wenn es null ist, die Länge des Strings standardmäßig 0 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;
$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, wenn nullableValue null ist, wird defaultValue auf -1 gesetzt. 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 Compiler-Warnung, weil nullableString null sein könnte und die Zuweisung an einen nicht-nullbaren Typ zu Laufzeitausnahmen führen könnte.

Verwendung von nullbaren Typen mit IronPDF

C# Nullable Types (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 - Beispiel Codeausgabe

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 Types (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, voranzuschreiten, beginnen Lizenzen ab $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 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

We're online 24 hours, 5 days a week.
Chat
Email
Call Me