Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Pomoc .NET
  4. Typy Nullable w języku C#
POMOC .NET

C# Typy Nullable (Jak to dziala dla programistow)

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
Zaktualizowano:

Podczas pracy z C# często trzeba obsługiwać wartości null, zwłaszcza przy typach referencyjnych. Typy nullable w C# oferują sposób reprezentowania nieokreślonych lub brakujących wartości dla typów wartościowych. Ten przewodnik obejmuje podstawy typów nullable w C#, ich praktyczne zastosowania oraz jak działają w różnych sytuacjach. W dalszej części artykułu zajmiemy się również IronPDF.

Typy nullable w C

Domyślnie typy wartościowe w C# (np. int, bool, DateTime) nie mogą być przypisane wartościom null. Aby rozwiązać to ograniczenie, C# wprowadza typy wartościowe nullable, które pozwalają na przypisanie null do typów wartościowych. Typy nullable są szczególnie przydatne, gdy trzeba przedstawić brak ważnej wartości.

Deklarowanie typów nullable

Aby zadeklarować typ nullable w C#, użyj następującej składni:

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

Tutaj, int? jest skrótem dla Nullable<int>. Zmiennej nullableInt można przypisać wartość int lub null.

Sprawdzanie na null

Aby sprawdzić, czy zmienna typu nullable ma wartość, czy nie, można użyć właściwości HasValue lub bezpośrednio porównać zmienną z null, jak pokazano poniżej:

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

Alternatywnie, można użyć operatora ??, aby zapewnić wartość domyślną, gdy typ nullable jest nullem:

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

Jeśli nullableInt jest nullem, result zostanie przypisana wartość domyślna 0.

Typy wartosciowe nullable a typy referencyjne nullable

W C# typy wartościowe (takie jak int, bool, double) różnią się od typów referencyjnych (jak string, object). Typy wartościowe nullable pozwalają na reprezentowanie null przez typy wartościowe, podczas gdy typy referencyjne nullable pozwalają na domyślną deklarację typów referencyjnych jako non-nullable, zmniejszając tym samym ryzyko wyjątków referencji null.

Typy wartosciowe nullable

Typ wartościowy nullable pozwala na przypisanie wartości null do typu wartościowego. Aby zadeklarować typ wartościowy nullable, dodaj znak zapytania ? do typu danych:

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

W tym przykładzie nullableDouble może mieć wartość double lub null.

Typy referencyjne nullable

Typy referencyjne nullable zostały wprowadzone w C# 8.0. Można włączyć typy referencyjne nullable na poziomie projektu lub dodając dyrektywę #nullable enable na początku pliku kodu. Przy włączonych typach referencyjnych nullable, typy referencyjne muszą być jawnie oznaczone jako nullable za pomocą ?, co pomaga uniknąć potencjalnych wyjątków podczas wykonania spowodowanych przez odniesienia null.

#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

Tutaj, nullableString jest dozwolone jako null. Jeśli zadeklarujesz typ referencyjny non-nullable bez ?, kompilator wygeneruje ostrzeżenia, jeśli wykryje potencjalne przypisania null.

Włączanie typów referencyjnych nullable

Aby włączyć typy referencyjne nullable globalnie w projekcie, dodaj poniższą linię do pliku .csproj:

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

Po włączeniu, kompilator będzie traktował typy referencyjne jako domyślnie non-nullable. Ta funkcja jest szczególnie przydatna do wychwytywania problemów z referencjami do null podczas kompilacji, a nie podczas wykonywania.

Praktyczne przykłady

Przyjrzyjmy się kilku praktycznym przykładom, aby utrwalić zrozumienie typów nullable.

Przykład 1: Typ nullable z typami wartościowymi

W tym przykładzie użyjemy typu nullable z int:

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

Tutaj, nullableInt jest zmienną typu nullable int. Jeśli nullableInt jest null, b otrzyma wartość 10 dzięki operatorowi ?? W przeciwnym razie, b otrzyma wartość nullableInt.

Przykład 2: Typy referencyjne nullable

Teraz zobaczmy, jak działają typy referencyjne nullable:

#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

W powyższym kodzie, nullableString może być null, a operator ?? zapewnia, że jeśli będzie null, długość ciągu zostanie ustawiona na 0.

Przykład 3: Zagnieżdżone typy nullable

C# pozwala deklarować zagnieżdżone typy nullable. Na przykład:

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

Chociaż zagnieżdżone typy nullable mogą wydawać się redundantne, są składniowo poprawne w C#. Jednak w praktyce zagnieżdżone typy nullable nie oferują żadnej dodatkowej funkcjonalności i są rzadko używane.

Operator ??

Operator ?? jest często używany z typami nullable, aby zapewnić wartość domyślną, gdy typ nullable jest null. Ten operator upraszcza kod, unikając jawnych instrukcji if-else.

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

W tym przykładzie, jeśli nullableValue jest null, defaultValue zostanie przypisane -1. W przeciwnym razie, defaultValue otrzyma wartość nullableValue.

Błędy kompilacji i typy nullable

Przy włączonych typach referencyjnych nullable, C# generuje ostrzeżenia i błędy podczas kompilacji, gdy wykryje potencjalne problemy z przypisaniami null. Te błędy kompilacji pomagają wcześnie wychwycić problemy, czyniąc twój kod bardziej solidnym.

Rozważmy następujący przykład:

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

W tym przypadku, przypisanie nullableString do nonNullableString generuje ostrzeżenie kompilatora, ponieważ nullableString może być null, a przypisanie go do typu niebędącego nullable może prowadzić do wyjątków w czasie wykonania.

Używanie typów nullable z IronPDF

C# Typy nullable (Jak to działa dla deweloperów): Rysunek 1 - IronPDF: C# biblioteka PDF

IronPDF to biblioteka PDF w C# zaprojektowana, aby pomagać deweloperom tworzyć, edytować i manipulować plikami PDF bezpośrednio w aplikacjach .NET. Można konwertować HTML na PDF, generować raporty lub nawet obsługiwać złożone struktury dokumentów.

Typy nullable są szczególnie przydatne w scenariuszach generowania dynamicznych raportów, takich jak generowanie PDF dla księgowego z niekompletnymi danymi finansowymi. Używając typów nullable, możesz obsługiwać opcjonalne pola, unikać wyjątków i zapewniać wartości domyślne.

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# Typy nullable (Jak to działa dla deweloperów): Rysunek 2 - Przykładowy kod

W tym kodzie, typy nullable (int? i string?) są używane do bezpiecznej obsługi braku danych. Operator ?? zapewnia, że jeśli jakiekolwiek dane są brakujące, w PDF zostanie użyta wartość domyślna.

Wnioski

C# Typy nullable (Jak to działa dla deweloperów): Rysunek 3 - strona licencyjna IronPDF

Typy nullable w C# są potężnym narzędziem do obsługi wartości null zarówno w typach wartościowych, jak i referencyjnych. Dzięki nim można uniknąć wyjątków referencyjnych null i zwiększyć odporność kodu. Pamiętaj, aby włączyć typy referencyjne nullable w nowych projektach, aby korzystać ze sprawdzania błędów podczas kompilacji. Używaj operatora ??, aby upraszczać kod przy obsłudze typów nullable.

IronPDF oferuje bezpłatną wersję próbną, aby pomóc ci odkryć jego funkcje, zanim podejmiesz decyzję. Bez wstępnych opłat możesz przetestować i sprawdzić, jak wpasowuje się w twój proces deweloperski. Gdy już będziesz gotowy do podjęcia dalszych kroków, licencje zaczynają się od $799.

Często Zadawane Pytania

W jaki sposób typy nullable mogą być wykorzystywane w dynamicznym generowaniu plików PDF?

Typy nullable mogą mieć kluczowe znaczenie w dynamicznym generowaniu plików PDF, umożliwiając bezpieczne przedstawianie pól opcjonalnych przy użyciu bibliotek takich jak IronPDF. Zapewnia to odpowiednie traktowanie brakujących danych, z podaniem wartości domyślnych tam, gdzie jest to konieczne.

Jaka jest składnia deklaracji typów nullable w języku C#?

W języku C# można zadeklarować typ nullable, dodając znak zapytania „?” do typu danych. Na przykład, aby zadeklarować liczbę całkowitą typu nullable, należy napisać int? nullableInt = null;.

Czy typy nullable w języku C# mogą wpływać na niezawodność generowanych raportów?

Tak, użycie typów nullable może zwiększyć niezawodność generowanych raportów, zapewniając, że pola opcjonalne nie powodują błędów, gdy ich wartości są nieobecne. Biblioteki takie jak IronPDF mogą wykorzystywać typy nullable do efektywnego zarządzania tymi warunkami.

W jaki sposób typy referencyjne z możliwością wartości null pomagają zapobiegać błędom w czasie wykonywania?

Typy referencyjne z możliwością wartości null, wprowadzone w C# 8.0, pomagają zapobiegać błędom wykonania, umożliwiając domyślne ustawienie typów referencyjnych jako nieprzyjmujących wartości null. Zmniejsza to ryzyko wystąpienia wyjątków związanych z odwołaniami null i pozwala na wczesne wykrywanie potencjalnych problemów podczas kompilacji.

Jaka jest rola operatora koalescencji wartości null w zarządzaniu typami, które mogą przyjmować wartość null?

Operator scalania wartości null ?? służy do zarządzania typami, które mogą przyjmować wartość null, zapewniając wartość domyślną, gdy typ taki ma wartość null. Upraszcza to kod i pomaga uniknąć jawnych sprawdzeń typu if-else.

Jak sprawdzić, czy typ nullable ma wartość w języku C#?

W języku C# można sprawdzić, czy typ nullable ma wartość, używając właściwości HasValue lub porównując zmienną bezpośrednio z wartością null.

Jakie są typowe scenariusze wykorzystania typów nullable w aplikacjach C#?

Typy nullable są często używane w sytuacjach, w których dane mogą być niekompletne lub opcjonalne, takich jak dane wprowadzane w formularzach, ustawienia konfiguracyjne lub podczas współpracy z bazami danych, które dopuszczają wartości null. Są one szczególnie przydatne podczas dynamicznego generowania raportów przy użyciu bibliotek takich jak IronPDF.

Jak włączenie typów referencyjnych z możliwością przyjmowania wartości null wpływa na kompilację projektu w języku C#?

Włączenie typów referencyjnych z możliwością wartości null w projekcie C# powoduje wyświetlanie ostrzeżeń i błędów kompilacji dotyczących potencjalnych problemów z odwołaniami null, co pozwala na wczesne wykrywanie problemów i sprzyja tworzeniu bardziej niezawodnego kodu.

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
  Czat z zespołem inżynierów teraz
Dyrektor ds. technologii

Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczą...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie