Czym jest operator warunkowy null w języku C#?

Operator warunkowy null w języku C#, znany również jako „operator Elvisa” (?.), pozwala programistom na dostęp do elementów lub metod tylko wtedy, gdy obiekt nie jest null, zapobiegając wyjątkom odwołania do wartości null i usprawniając obsługę wartości null.

W jaki sposób operator warunkowy null w języku C# może poprawić czytelność kodu?

Dzięki zmniejszeniu liczby wymaganych jawnych sprawdzeń wartości null operator warunkowy null w języku C# sprawia, że kod jest bardziej przejrzysty i czytelny, pozwalając programistom skupić się na logice podstawowej, a nie na sprawdzaniu wartości null.

Czy operator warunkowy null może być używany z operatorem scałającym null?

Tak, operator warunkowy null można połączyć z operatorem scałającym null (??), aby zapewnić wartość domyślną, gdy wyrażenie zwraca null, zwiększając niezawodność i bezpieczeństwo kodu.

W jaki sposób operator warunkowy Null wpływa na bezpieczeństwo wątków?

Zwiększa bezpieczeństwo wątków, umożliwiając bezpieczny dostęp do współdzielonych zasobów bez ryzyka wystąpienia wyjątków odwołania do wartości null, co ma kluczowe znaczenie podczas pracy z aplikacjami wielowątkowymi.

Jakie są praktyczne zastosowania operatora warunkowego Null?

Praktyczne zastosowania obejmują uproszczenie obsługi zdarzeń za pomocą składni takiej jak PropertyChanged?.Invoke oraz bezpieczny dostęp do elementów w kolekcjach bez ryzyka wystąpienia wyjątków null reference.

Jak można użyć IronPDF do konwersji HTML na PDF w języku C#?

IronPDF może konwertować HTML na PDF w języku C# przy użyciu metod takich jak RenderHtmlAsPdf dla ciągów znaków HTML lub RenderHtmlFileAsPdf dla plików HTML, zapewniając zachowanie stylu.

Jaka jest rola operatora warunkowego Null w generowaniu plików PDF za pomocą IronPDF?

Operator warunkowy null może być używany do bezpiecznego uzyskiwania dostępu do właściwości dokumentów PDF podczas generowania plików PDF za pomocą IronPDF, poprawiając obsługę wartości null w trakcie tego procesu.

Jak zainstalować IronPDF w projekcie .NET?

IronPDF można zainstalować w projekcie .NET za pomocą menedżera pakietów NuGet, używając polecenia Install-Package IronPdf .

Jakie korzyści oferuje operator warunkowy null w programowaniu w języku C#?

Operator warunkowy null zmniejsza złożoność kodu, zapobiega wyjątkom odwołania do wartości null i poprawia łatwość utrzymania kodu, co czyni go cennym narzędziem dla programistów C#.

Czy IronPDF może być używany z typami nullable w C#?

Tak, IronPDF można zintegrować z typami nullable w języku C#, używając operatora warunkowego null, aby płynnie obsługiwać wartości null podczas operacji na plikach PDF.

Biblioteka PDF dla C#

Explore IronPDF Bezpłatna próba

HTML do PDF

Online Demo Zobacz wszystkie przykłady kodu %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >

Install-Package IronPdf

AKTUALNOŚCI DLA PROGRAMISTÓW

Operator warunkówy null w języku C# (jak działa dla programistów)

Jacob Mellor

Updated: 21 kwietnia 2026

Operator warunkowy null w języku C# oferuje bardziej zwięzły i bezpieczny sposób obsługi wartości null w kodzie. Zaletą tego operatora jest możliwość uproszczenia sprawdzania wartości null, dzięki czemu kod staje się bardziej przejrzysty i czytelny.

Przejdźmy do szczegółów na temat tego, jak działa null operator warunkowy, jakie ma zalety i jak można go użyć w swoich projektach. Przyjrzymy się również IronPDF i jego zastosowaniom oraz jego zastosowaniu z Null operatorem warunkowym.

Czym jest operator warunkowy null?

Operator warunkowy null, często nazywany "operatorem Elvisa" ze względu na podobieństwo do fryzury Elvisa Presleya (?.), pozwala na dostęp do elementów lub wywołanie metod obiektu tylko wtedy, gdy obiekt ten nie jest null.

Jeśli obiekt ma wartość null, operacja zwraca null zamiast zgłaszać wyjątek odwołania do wartości null. Ten operator stanowi przełom dla programistów, ponieważ znacznie zmniejsza ilość kodu potrzebnego do bezpiecznego uzyskania dostępu do elementów obiektów, które mogą być null.

Podstawy operatorów warunkowych typu null

Aby zrozumieć operator warunkowy null, rozważmy przykład klasy publicznej Employee. Ta klasa może posiadać takie właściwości, jak public string FirstName oraz public string LastName. W tradycyjnym kodzie C# dostęp do właściwości obiektu Employee, który może mieć wartość null, wymaga wyraźnych sprawdzeń wartości null, aby uniknąć wyjątków:

if (employee != null)
{
    var name = employee.FirstName;
}

if (employee != null)
{
    var name = employee.FirstName;
}

If employee IsNot Nothing Then
	Dim name = employee.FirstName
End If

If employee IsNot Nothing Then
	Dim name = employee.FirstName
End If

Jednak dzięki operatorowi warunkowemu null można to uprościć do jednej linii:

var name = employee?.FirstName;

var name = employee?.FirstName;

Dim name = employee?.FirstName

Dim name = employee?.FirstName

Jeśli employee nie jest null, zmienna name otrzymuje wartość employee.FirstName. Jeśli pracownik jest null, nazwa jest ustawiana na null. Ta pojedyncza linia kodu elegancko zastępuje w ten sposób wiele linii jawnych sprawdzeń wartości null.

Łączenie z operatorami koalescencji wartości null

Operator warunkowy null staje się jeszcze potężniejszy w połączeniu z operatorem przypisania scałającego null (??=). Operator koalescencji wartości null pozwala określić wartość domyślną na wypadek, gdyby wyrażenie dało w wyniku wartość null.

Na przykład, jeśli chcesz zapewnić, że zmienna name ma wartość domyślną "Unknown" zamiast null, możesz napisać:

var name = employee?.FirstName ?? "Unknown";

var name = employee?.FirstName ?? "Unknown";

Dim name = If(employee?.FirstName, "Unknown")

Dim name = If(employee?.FirstName, "Unknown")

Ten kod sprawdza, czy employee ma wartość null, a następnie przypisuje "Unknown" do name, jeśli employee.FirstName ma wartość null. Elegancko radzi sobie z wartościami null w jednej operacji, pokazując, jak zwięzły i efektywny może stać się Twój kod.

W języku C# wprowadzono typy nullable, które pozwalają zmiennym przechowywać albo wartość niezerową swojego typu bazowego, albo wartość null.

Zaawansowane zastosowanie: warunek null i kolekcje

Podczas pracy z kolekcjami można użyć operatora warunkowego null, aby uzyskać dostęp do elementu bez ryzyka wystąpienia wyjątku odwołania do wartości null. Załóżmy, że masz listę pracowników i chcesz bezpiecznie uzyskać dostęp do imienia pierwszego elementu. Możesz użyć operatora w nawiasach kwadratowych:

var firstName = employees?[0]?.FirstName ?? "Unknown";

var firstName = employees?[0]?.FirstName ?? "Unknown";

Dim firstName = If(employees?(0)?.FirstName, "Unknown")

Dim firstName = If(employees?(0)?.FirstName, "Unknown")

Ta linia kodu jest bezpieczna dla wątków, co oznacza, że gwarantuje, iż jeśli inny wątek zmieni wartość employees na null po sprawdzeniu wartości null, ale przed uzyskaniem dostępu do pierwszego elementu, kod nie ulegnie awarii. W przypadku typów nullable ważne jest zrozumienie ich typu wartości bazowego, który jest typem nie-nullable powiązanym z typem nullable.

Bezpieczeństwo wątków i operator warunkowy null

Jedną z subtelności korzystania z operatora warunkowego null jest jego bezpieczeństwo wątków. Gdy używasz tego operatora, obliczenie wyrażenia jest bezpieczne dla wątków. Oznacza to, że jeśli uzyskujesz dostęp do współdzielonego zasobu, który może zostać zmodyfikowany przez inny wątek, użycie operatora warunkowego null może zapobiec potencjalnym sytuacjom wyścigu.

Należy jednak pamiętać, że chociaż sam operator jest bezpieczny dla wątków w zakresie wykonywanej operacji, nie gwarantuje to bezpieczeństwa dla całego bloku kodu lub sekwencji operacji.

Praktyczny przykład

Rozważmy bardziej praktyczny przykład, w którym mamy obiekt, który może wywołać zdarzenie. W tradycyjnym C# przed wywołaniem zdarzenia sprawdzałbyś, czy obsługa zdarzenia ma wartość null, aby uniknąć wyjątku odwołania do wartości null:

if (PropertyChanged != null)
{
    PropertyChanged(this, new PropertyChangedEventArgs(name));
}

if (PropertyChanged != null)
{
    PropertyChanged(this, new PropertyChangedEventArgs(name));
}

If PropertyChanged IsNot Nothing Then
	PropertyChanged(Me, New PropertyChangedEventArgs(name))
End If

If PropertyChanged IsNot Nothing Then
	PropertyChanged(Me, New PropertyChangedEventArgs(name))
End If

Dzięki operatorowi warunkowemu null można to uprościć do:

PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));

PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));

If PropertyChanged IsNot Nothing Then
	PropertyChanged.Invoke(Me, New PropertyChangedEventArgs(name))
End If

If PropertyChanged IsNot Nothing Then
	PropertyChanged.Invoke(Me, New PropertyChangedEventArgs(name))
End If

Ten zwięzły kod pozwala osiągnąć ten sam rezultat, ale w sposób bardziej czytelny i bezpieczny. W sytuacjach, gdy chcesz jawnie zwrócić null, możesz po prostu użyć instrukcji return null;. Operator ?. przerywa operację, jeśli PropertyChanged ma wartość null, zapobiegając w ten sposób wystąpieniu wyjątku. Oto pełny kod:

using System.ComponentModel;

// Define a Person class that implements the INotifyPropertyChanged interface
public class Person : INotifyPropertyChanged
{
    private string name;

    // Event that is raised when a property changes
    public event PropertyChangedEventHandler PropertyChanged;

    // Property for the person's name with a getter and setter
    public string Name
    {
        get { return name; }
        set
        {
            if (name != value)
            {
                name = value;
                OnPropertyChanged(nameof(Name)); // Notify that the property has changed
            }
        }
    }

    // Method to invoke the PropertyChanged event safely using the null conditional operator
    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Create a new Person instance and subscribe to the PropertyChanged event
        Person person = new Person();
        person.PropertyChanged += (sender, e) =>
        {
            Console.WriteLine($"{e.PropertyName} property has changed.");
        };

        // Change the person's name, triggering the PropertyChanged event
        person.Name = "Iron Software";
    }
}

using System.ComponentModel;

// Define a Person class that implements the INotifyPropertyChanged interface
public class Person : INotifyPropertyChanged
{
    private string name;

    // Event that is raised when a property changes
    public event PropertyChangedEventHandler PropertyChanged;

    // Property for the person's name with a getter and setter
    public string Name
    {
        get { return name; }
        set
        {
            if (name != value)
            {
                name = value;
                OnPropertyChanged(nameof(Name)); // Notify that the property has changed
            }
        }
    }

    // Method to invoke the PropertyChanged event safely using the null conditional operator
    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Create a new Person instance and subscribe to the PropertyChanged event
        Person person = new Person();
        person.PropertyChanged += (sender, e) =>
        {
            Console.WriteLine($"{e.PropertyName} property has changed.");
        };

        // Change the person's name, triggering the PropertyChanged event
        person.Name = "Iron Software";
    }
}

Imports System.ComponentModel

' Define a Person class that implements the INotifyPropertyChanged interface
Public Class Person
	Implements INotifyPropertyChanged

'INSTANT VB NOTE: The field name was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private name_Conflict As String

	' Event that is raised when a property changes
	Public Event PropertyChanged As PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged

	' Property for the person's name with a getter and setter
	Public Property Name() As String
		Get
			Return name_Conflict
		End Get
		Set(ByVal value As String)
			If name_Conflict <> value Then
				name_Conflict = value
				OnPropertyChanged(NameOf(Name)) ' Notify that the property has changed
			End If
		End Set
	End Property

	' Method to invoke the PropertyChanged event safely using the null conditional operator
	Protected Overridable Sub OnPropertyChanged(ByVal propertyName As String)
		RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(propertyName))
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Create a new Person instance and subscribe to the PropertyChanged event
		Dim person As New Person()
		AddHandler person.PropertyChanged, Sub(sender, e)
			Console.WriteLine($"{e.PropertyName} property has changed.")
		End Sub

		' Change the person's name, triggering the PropertyChanged event
		person.Name = "Iron Software"
	End Sub
End Class

Imports System.ComponentModel

' Define a Person class that implements the INotifyPropertyChanged interface
Public Class Person
	Implements INotifyPropertyChanged

'INSTANT VB NOTE: The field name was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private name_Conflict As String

	' Event that is raised when a property changes
	Public Event PropertyChanged As PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged

	' Property for the person's name with a getter and setter
	Public Property Name() As String
		Get
			Return name_Conflict
		End Get
		Set(ByVal value As String)
			If name_Conflict <> value Then
				name_Conflict = value
				OnPropertyChanged(NameOf(Name)) ' Notify that the property has changed
			End If
		End Set
	End Property

	' Method to invoke the PropertyChanged event safely using the null conditional operator
	Protected Overridable Sub OnPropertyChanged(ByVal propertyName As String)
		RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(propertyName))
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Create a new Person instance and subscribe to the PropertyChanged event
		Dim person As New Person()
		AddHandler person.PropertyChanged, Sub(sender, e)
			Console.WriteLine($"{e.PropertyName} property has changed.")
		End Sub

		' Change the person's name, triggering the PropertyChanged event
		person.Name = "Iron Software"
	End Sub
End Class

Oto wynik działania kodu:

C# Operator warunkowy dla wartości null (Jak Działa dla Deweloperów): Rysunek 1

Wprowadzenie do IronPDF w projektach C#

IronPDF to wszechstronna biblioteka dla programistów C#, która umożliwia tworzenie, edycję i wyodrębnianie treści PDF w aplikacjach .NET. Biblioteka ta wyróżnia się łatwością użytkowania oraz możliwością płynnej integracji funkcji PDF z dowolnym projektem .NET.

Najważniejszą funkcją IronPDF jest konwersja HTML do PDF z zachowaniem całego stylu, w tym pełnego układu i stylistyki. To świetne rozwiązanie do generowania plików PDF z treści internetowych, w tym raportów, faktur i dokumentacji. Obsługuje konwersję plików HTML, adresów URL i ciągów znaków HTML do plików PDF.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
        
        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
        
        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
        
        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
        
        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()

        ' 1. Convert HTML String to PDF
        Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
        Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

        ' 2. Convert HTML File to PDF
        Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
        Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

        ' 3. Convert URL to PDF
        Dim url = "http://ironpdf.com" ' Specify the URL
        Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
        pdfFromUrl.SaveAs("URLToPDF.pdf")
    End Sub
End Module

Imports IronPdf

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()

        ' 1. Convert HTML String to PDF
        Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
        Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

        ' 2. Convert HTML File to PDF
        Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
        Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

        ' 3. Convert URL to PDF
        Dim url = "http://ironpdf.com" ' Specify the URL
        Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
        pdfFromUrl.SaveAs("URLToPDF.pdf")
    End Sub
End Module

Niezależnie od tego, czy generujesz raporty, faktury czy dowolne dokumenty w formacie PDF, IronPDF zapewnia kompleksowy zestaw narzędzi do wydajnego wykonywania tych zadań.

Integracja IronPDF z operatorami warunkowymi Null

Włączenie IronPDF do projektu w celu obsługi plików PDF w połączeniu z operatorami warunkowymi null może znacznie zwiększyć niezawodność aplikacji. Ta kombinacja jest szczególnie przydatna w przypadku treści PDF, które mogą być puste, lub podczas wykonywania operacji, które mogą potencjalnie skutkować wartością null.

Przyjrzyjmy się prostemu przykładowi, w którym używamy IronPDF do generowania dokumentu PDF na podstawie treści HTML. Następnie użyjemy operatora warunkowego null, aby bezpiecznie uzyskać dostęp do właściwości dokumentu, ilustrując, jak elegancko radzić sobie z wartościami null.

Instalacja IronPDF

Najpierw musisz dodać IronPDF do swojego projektu. Można to zrobić za pomocą menedżera pakietów NuGet:

PM > Install-Package IronPdf

Install-Package IronPdf

Teraz wpisz następujący kod do pliku Program.cs:

using IronPdf;
using System;

public class PdfGenerator
{
    public static void CreatePdf(string htmlContent, string outputPath)
    {
        // Instantiate the HtmlToPdf converter
        var renderer = new IronPdf.ChromePdfRenderer();

        // Generate a PDF document from HTML content
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

        // Use the null conditional operator to safely access the document's properties
        var pageCount = pdfDocument?.PageCount ?? 0;

        // Check if the PDF was generated successfully and has pages
        if (pageCount > 0)
        {
            // Save the PDF document to the specified output path
            pdfDocument.SaveAs(outputPath);
            Console.WriteLine($"PDF created successfully with {pageCount} pages.");
        }
        else
        {
            // Handle cases where the PDF generation fails or returns null
            Console.WriteLine("Failed to create PDF or the document is empty.");
        }
    }

    public static void Main(string[] args)
    {
        // Define the HTML content for the PDF document
        string htmlContent = @"
            <html>
            <head>
                <title>Test PDF</title>
            </head>
            <body>
                <h1>Hello, IronPDF!</h1>
                <p>This is a simple PDF document generated from HTML using IronPDF.</p>
            </body>
            </html>";

        // Specify the path where the PDF document will be saved
        // Ensure this directory exists on your machine or adjust the path accordingly
        string filePath = @"F:\GeneratedPDF.pdf";

        // Call the method to generate and save the PDF document
        CreatePdf(htmlContent, filePath);

        // Wait for user input before closing the console window
        Console.WriteLine("Press any key to exit...");
        Console.ReadKey();
    }
}

using IronPdf;
using System;

public class PdfGenerator
{
    public static void CreatePdf(string htmlContent, string outputPath)
    {
        // Instantiate the HtmlToPdf converter
        var renderer = new IronPdf.ChromePdfRenderer();

        // Generate a PDF document from HTML content
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

        // Use the null conditional operator to safely access the document's properties
        var pageCount = pdfDocument?.PageCount ?? 0;

        // Check if the PDF was generated successfully and has pages
        if (pageCount > 0)
        {
            // Save the PDF document to the specified output path
            pdfDocument.SaveAs(outputPath);
            Console.WriteLine($"PDF created successfully with {pageCount} pages.");
        }
        else
        {
            // Handle cases where the PDF generation fails or returns null
            Console.WriteLine("Failed to create PDF or the document is empty.");
        }
    }

    public static void Main(string[] args)
    {
        // Define the HTML content for the PDF document
        string htmlContent = @"
            <html>
            <head>
                <title>Test PDF</title>
            </head>
            <body>
                <h1>Hello, IronPDF!</h1>
                <p>This is a simple PDF document generated from HTML using IronPDF.</p>
            </body>
            </html>";

        // Specify the path where the PDF document will be saved
        // Ensure this directory exists on your machine or adjust the path accordingly
        string filePath = @"F:\GeneratedPDF.pdf";

        // Call the method to generate and save the PDF document
        CreatePdf(htmlContent, filePath);

        // Wait for user input before closing the console window
        Console.WriteLine("Press any key to exit...");
        Console.ReadKey();
    }
}

Imports IronPdf
Imports System

Public Class PdfGenerator
	Public Shared Sub CreatePdf(ByVal htmlContent As String, ByVal outputPath As String)
		' Instantiate the HtmlToPdf converter
		Dim renderer = New IronPdf.ChromePdfRenderer()

		' Generate a PDF document from HTML content
		Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)

		' Use the null conditional operator to safely access the document's properties
		Dim pageCount = If(pdfDocument?.PageCount, 0)

		' Check if the PDF was generated successfully and has pages
		If pageCount > 0 Then
			' Save the PDF document to the specified output path
			pdfDocument.SaveAs(outputPath)
			Console.WriteLine($"PDF created successfully with {pageCount} pages.")
		Else
			' Handle cases where the PDF generation fails or returns null
			Console.WriteLine("Failed to create PDF or the document is empty.")
		End If
	End Sub

	Public Shared Sub Main(ByVal args() As String)
		' Define the HTML content for the PDF document
		Dim htmlContent As String = "
            <html>
            <head>
                <title>Test PDF</title>
            </head>
            <body>
                <h1>Hello, IronPDF!</h1>
                <p>This is a simple PDF document generated from HTML using IronPDF.</p>
            </body>
            </html>"

		' Specify the path where the PDF document will be saved
		' Ensure this directory exists on your machine or adjust the path accordingly
		Dim filePath As String = "F:\GeneratedPDF.pdf"

		' Call the method to generate and save the PDF document
		CreatePdf(htmlContent, filePath)

		' Wait for user input before closing the console window
		Console.WriteLine("Press any key to exit...")
		Console.ReadKey()
	End Sub
End Class

Imports IronPdf
Imports System

Public Class PdfGenerator
	Public Shared Sub CreatePdf(ByVal htmlContent As String, ByVal outputPath As String)
		' Instantiate the HtmlToPdf converter
		Dim renderer = New IronPdf.ChromePdfRenderer()

		' Generate a PDF document from HTML content
		Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)

		' Use the null conditional operator to safely access the document's properties
		Dim pageCount = If(pdfDocument?.PageCount, 0)

		' Check if the PDF was generated successfully and has pages
		If pageCount > 0 Then
			' Save the PDF document to the specified output path
			pdfDocument.SaveAs(outputPath)
			Console.WriteLine($"PDF created successfully with {pageCount} pages.")
		Else
			' Handle cases where the PDF generation fails or returns null
			Console.WriteLine("Failed to create PDF or the document is empty.")
		End If
	End Sub

	Public Shared Sub Main(ByVal args() As String)
		' Define the HTML content for the PDF document
		Dim htmlContent As String = "
            <html>
            <head>
                <title>Test PDF</title>
            </head>
            <body>
                <h1>Hello, IronPDF!</h1>
                <p>This is a simple PDF document generated from HTML using IronPDF.</p>
            </body>
            </html>"

		' Specify the path where the PDF document will be saved
		' Ensure this directory exists on your machine or adjust the path accordingly
		Dim filePath As String = "F:\GeneratedPDF.pdf"

		' Call the method to generate and save the PDF document
		CreatePdf(htmlContent, filePath)

		' Wait for user input before closing the console window
		Console.WriteLine("Press any key to exit...")
		Console.ReadKey()
	End Sub
End Class

Wynik

Oto wynik wyświetlany w konsoli po uruchomieniu programu:

C# Operator warunkowy dla wartości null (Jak Działa dla Deweloperów): Rysunek 2

A oto plik PDF wygenerowany przez program:

C# Operator warunkowy dla wartości null (Jak Działa dla Deweloperów): Rysunek 3

Wnioski

C# Operator warunkowy dla wartości null (Jak Działa dla Deweloperów): Rysunek 4

Zintegrowanie IronPDF z operatorami warunkowymi null w projektach C# może znacznie usprawnić obsługę plików PDF, jednocześnie zapewniając ochronę kodu przed wyjątkami null reference. Ten przykład pokazał synergię między potężną biblioteką PDF a nowoczesnymi funkcjami języka C#, umożliwiając pisanie czystszego i łatwiejszego w utrzymaniu kodu.

Pamiętaj, że kluczem do efektywnego wykorzystania tych narzędzi jest zrozumienie ich możliwości i rozsądne stosowanie ich w swoich projektach.

IronPDF oferuje programistom bezpłatną wersję próbną z pełnym wsparciem i aktualizacjami, zaczynającą się od Lite License.

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ącą ponad 50 osób, obsługującą NASA, Teslę i światowe agencje rządowe.

...

Czytaj więcej