Nie znalazłeś tego, czego szukałeś?
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ługiwac wartosci null, zwlaszcza przy typach referencyjnych. Typy nullable w C# oferuja sposob reprezentowania nieokreslonych lub zabrakujacych wartosci dla typow wartosciowych. Ten przewodnik obejmuje podstawy typow nullable w C#, ich praktyczne zastosowania oraz jak działaja w różnych sytuacjach. W dalszej części artykułu zajmiemy sie również IronPDF.

Nullable Types in C

Domyslnie typy wartosciowe w C# (np. int, bool, DateTime) nie mogą być przypisane wartosciom null. Aby rozwiązać to ograniczenie, C# wprowadza typy wartosciowe nullable, ktore pozwalają na przypisanie null do typow wartosciowych. Typy nullable sa szczegółnie przydatne, gdy trzeba przedstawic brak ważnej wartosci.

Deklarowanie typow nullable

Aby zadeklarowac typ nullable w C#, uzyj następującej skladni:

// 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ść typu int lub null.

Sprawdzanie na null

Aby sprawdzić, czy zmienna nullable ma wartość, czy nie, można użyć właściwości HasValue albo porównać zmienną bezpośrednio 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 uzyc operatora ??, aby zapewnic wartosc domyslna, 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 null, to result zostanie przypisane wartością domyślną 0.

Typy wartosciowe nullable a typy referencyjne nullable

W C# typy wartosciowe (takie jak int, bool, double) różnią sie od typow referencyjnych (jak string, object). Typy wartosciowe nullable pozwalają na reprezentowanie null przez typy wartosciowe, podczas gdy typy referencyjne nullable pozwalają na domyslna deklaracje typow referencyjnych jako non-nullable, zmniejszajac tym samym ryzyko wyjątków referencji null.

Typy wartosciowe nullable

Typ wartosciowy nullable pozwala na przypisanie wartosci null do typu wartosciowego. Aby zadeklarować typ 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 przechowywać wartość double lub null.

Typy referencyjne nullable

Nullable reference types zostały wprowadzone w C# 8.0. Można je włączyć na poziomie projektu lub poprzez dodanie dyrektywy #nullable enable na początku pliku kodu. Po włączeniu nullable reference types typy referencyjne muszą być wyraźnie oznaczone jako nullable za pomocą ?, co pomaga uniknąć potencjalnych wyjątków w czasie wykonania spowodowanych przez 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 może być 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 globalnie włączyć nullable reference types w projekcie, dodaj następującą 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, to b przyjmie wartość 10 dzięki operatorowi złączenia null. W przeciwnym razie b przyjmie 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 złączenia null zapewnia, że jeśli jest null, to długość ciągu jest domyślnie 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, to defaultValue zostanie przypisane -1. W przeciwnym razie defaultValue przyjmie 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 powoduje ostrzeżenie kompilatora, ponieważ nullableString może być null, a przypisanie go do typu non-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# PDF Library

IronPDF to biblioteka PDF dla 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ługiwac zlozone struktury dokumentów.

Typy nullable sa szczegółnie przydatne w scenariuszach generowania dynamicznych raportow, takich jak generowanie PDF dla ksiegowego z niepełna dane finansowe. Używając typow nullable, możesz obsługiwac opcjonalne pola, unikac wyjątków i zapewnic wartosci domyslne.

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ład wyniku kodu

W tym kodzie typy nullable (int? i string?) są używane do bezpiecznego obsługiwania brakujących danych. Operator ?? zapewnia, ze jeśli jakiekolwiek dane są brakujace, w PDF zostanie uzuta wartosc domyslna.

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 bezplataną 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 na kolejny krok, licencje zaczynają się od $999.

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 scałania 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

Zespół wsparcia Iron

Jesteśmy online 24 godziny, 5 dni w tygodniu.
Czat
E-mail
Zadzwoń do mnie