O que é o operador condicional nulo em C#?

O operador condicional nulo em C#, também conhecido como 'operador Elvis' (?.), permite que os desenvolvedores acessem membros ou métodos somente se o objeto não for nulo, evitando exceções de referência nula e simplificando o tratamento de valores nulos.

Como o operador condicional nulo em C# pode melhorar a legibilidade do código?

Ao reduzir o número de verificações explícitas de nulos necessárias, o operador condicional nulo do C# torna o código mais limpo e legível, permitindo que os desenvolvedores se concentrem na lógica principal em vez da validação de nulos.

O operador condicional nulo pode ser usado com o operador de coalescência nula?

Sim, o operador condicional nulo pode ser combinado com o operador de coalescência nula (??) para fornecer um valor padrão quando uma expressão for avaliada como nula, aumentando a robustez e a segurança do código.

Como o operador condicional nulo afeta a segurança de threads?

Isso aprimora a segurança de threads, permitindo o acesso seguro a recursos compartilhados sem o risco de exceções de referência nula, o que é crucial ao trabalhar com aplicativos multithread.

Quais são algumas aplicações práticas do operador condicional nulo?

As aplicações práticas incluem a simplificação do tratamento de eventos com sintaxe como PropertyChanged?.Invoke e o acesso seguro a elementos em coleções sem o risco de exceções de referência nula.

Como usar o IronPDF para converter HTML em PDF em C#?

O IronPDF pode converter HTML para PDF em C# usando métodos como RenderHtmlAsPdf para strings HTML ou RenderHtmlFileAsPdf para arquivos HTML, garantindo a preservação do estilo.

Qual é o papel do operador condicional nulo na geração de PDFs com o IronPDF?

O operador condicional nulo pode ser usado para acessar com segurança as propriedades de documentos PDF ao gerar PDFs com o IronPDF, melhorando o tratamento de valores nulos durante o processo.

Como instalar o IronPDF em um projeto .NET?

O IronPDF pode ser instalado em um projeto .NET através do Gerenciador de Pacotes NuGet usando o comando Install-Package IronPDF .

Quais são os benefícios que o operador condicional nulo oferece no desenvolvimento em C#?

O operador condicional nulo reduz a complexidade do código, evita exceções de referência nula e melhora a manutenção do código, tornando-se uma ferramenta valiosa para desenvolvedores C#.

É possível usar o IronPDF com tipos anuláveis em C#?

Sim, o IronPDF pode ser integrado a tipos anuláveis em C# usando o operador condicional nulo para lidar com valores nulos de forma adequada durante as operações de PDF.

A biblioteca C# PDF

Explore IronPDF Comece seu teste gratuito

HTML para PDF

Online Demo Veja todos os exemplos de código %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

Install-Package IronPdf

ATUALIZAÇÕES DO DESENVOLVEDOR

Operador condicional nulo em C# (Como funciona para desenvolvedores)

Curtis Chau

Updated: 21 de abril de 2026

O operador condicional nulo em C# oferece uma maneira mais concisa e segura de lidar com valores nulos em seu código. A beleza desse operador reside em sua capacidade de simplificar as verificações de valores nulos, tornando seu código mais limpo e legível.

Vamos mergulhar nos detalhes de como o null operador condicional funciona, seus benefícios, e como você pode usá-lo em seus projetos. Exploraremos também o IronPDF e seus casos de uso e seu caso de uso com o operador condicional Null.

O que é o operador condicional nulo?

O operador condicional nulo, frequentemente chamado de "operador Elvis" devido à sua semelhança com o penteado de Elvis Presley ( ?. ), permite que você acesse membros ou faça chamadas de método em um objeto somente se esse objeto não for nulo.

Se o objeto for nulo, a operação retorna nulo em vez de lançar uma exceção de referência nula. Este operador é revolucionário para desenvolvedores, pois reduz significativamente a quantidade de código necessária para acessar com segurança membros de objetos potencialmente nulos.

Noções básicas de operadores condicionais nulos

Para entender o operador condicional nulo, considere o exemplo da classe pública Employee . Esta classe pode ter propriedades como public string FirstName e public string LastName . Em código C# tradicional, acessar uma propriedade de um objeto Employee potencialmente nulo requer verificações explícitas de nulidade para evitar exceções:

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

No entanto, com o operador condicional nulo, você pode simplificar isso para uma única linha:

var name = employee?.FirstName;

var name = employee?.FirstName;

Dim name = employee?.FirstName

Dim name = employee?.FirstName

Se o funcionário não for nulo, a variável nome receberá o valor de employee.FirstName . Se o funcionário for nulo, o nome será definido como nulo. Essa única linha de código substitui, de forma elegante, várias linhas de verificações explícitas de valores nulos.

Combinando com operadores de coalescência nula

O operador condicional nulo torna-se ainda mais poderoso quando combinado com o operador de atribuição coalescente nulo ( ??= ). O operador de coalescência nula permite especificar um valor padrão caso uma expressão seja avaliada como nula.

Por exemplo, se você quiser garantir que a variável name tenha o valor padrão "Desconhecido" em vez de nulo, você pode escrever:

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

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

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

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

Este código verifica se o campo "employee" é nulo e, em seguida, atribui "Unknown" ao campo "name" caso "employee.FirstName" seja nulo. Ele lida com valores nulos de forma elegante em uma única operação, demonstrando o quão conciso e eficaz seu código pode se tornar.

O C# introduziu os tipos anuláveis, que permitem que as variáveis armazenem um valor não nulo do seu tipo subjacente ou nulo.

Uso avançado: condicionais nulas e coleções

Ao trabalhar com coleções, o operador condicional nulo pode ser usado para acessar um elemento sem correr o risco de uma exceção de referência nula. Suponha que você tenha uma lista de funcionários e queira acessar o nome do primeiro elemento com segurança. Você pode usar o operador entre colchetes:

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")

Essa linha de código é thread-safe, o que significa que garante que, se outra thread alterar o valor de employees para null após a verificação de nulo, mas antes de acessar seu primeiro elemento, seu código não falhará. Ao lidar com tipos anuláveis, é importante entender o tipo de valor subjacente, que é o tipo não anulável associado ao tipo anulável.

Segurança de roscas e o operador condicional nulo

Uma das sutilezas do uso do operador condicional nulo é sua característica de segurança de threads. Ao usar esse operador, a avaliação da expressão é segura para uso em múltiplas threads. Isso significa que, se você estiver acessando um recurso compartilhado que pode ser modificado por outra thread, usar o operador condicional nulo pode evitar possíveis condições de corrida.

No entanto, é importante entender que, embora o operador em si seja thread-safe para a operação que executa, isso não garante a segurança de threads para todo o seu bloco de código ou sequência de operações.

Exemplo prático

Vamos considerar um exemplo mais prático, onde você tem um objeto que pode gerar um evento. Em C# tradicional, você verificaria se o manipulador de eventos é nulo antes de invocar o evento para evitar uma exceção de referência nula:

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

Com o operador condicional nulo, isso pode ser simplificado para:

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

Este código conciso alcança o mesmo resultado, mas de uma forma mais legível e segura. Em cenários onde você deseja explicitamente retornar null, você pode simplesmente usar a instrução return null;. O operador ?. interrompe a operação se PropertyChanged for nulo, evitando assim uma exceção. Aqui está o código completo:

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

Aqui está o resultado do código:

Operador Condicional Nulo C# (Como Funciona Para Desenvolvedores): Figura 1

Introdução ao IronPDF em Projetos C#

IronPDF é uma biblioteca versátil para desenvolvedores C# que permite criar, editar e extrair conteúdo de PDFs em aplicações .NET . Esta biblioteca se destaca pela sua facilidade de uso e pela capacidade de integrar perfeitamente as funcionalidades de PDF em qualquer projeto .NET .

A principal funcionalidade do IronPDF é a conversão de HTML para PDF com preservação completa do estilo , mantendo o layout e o estilo originais. É uma ótima solução para gerar PDFs a partir de conteúdo da web, incluindo relatórios, faturas e documentação. Ele suporta a conversão de arquivos HTML, URLs e strings HTML em arquivos 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

Seja para gerar relatórios, faturas ou qualquer documento em formato PDF, o IronPDF oferece um conjunto completo de ferramentas para realizar essas tarefas com eficiência.

Integrando o IronPDF com operadores condicionais nulos

Integrar o IronPDF ao seu projeto para lidar com PDFs em conjunto com operadores condicionais nulos pode melhorar significativamente a robustez da sua aplicação. Essa combinação é particularmente útil ao lidar com conteúdo de PDF que pode ser nulo ou ao realizar operações que podem resultar em um valor nulo.

Vamos explorar um exemplo simples onde usamos o IronPDF para gerar um documento PDF a partir de conteúdo HTML. Em seguida, usaremos o operador condicional nulo para acessar com segurança as propriedades do documento, ilustrando como lidar com valores nulos de forma adequada.

Instalando o IronPDF

Primeiro, você precisa adicionar o IronPDF ao seu projeto. Você pode fazer isso através do Gerenciador de Pacotes NuGet :

PM > Install-Package IronPdf

Install-Package IronPdf

Agora escreva o seguinte código no arquivo 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

Saída

Aqui está a saída do console ao executar o programa:

Operador Condicional Nulo C# (Como Funciona Para Desenvolvedores): Figura 2

E este é o PDF gerado pelo programa:

Operador Condicional Nulo C# (Como Funciona Para Desenvolvedores): Figura 3

Conclusão

Integrar o IronPDF com operadores condicionais nulos em seus projetos C# pode simplificar significativamente suas tarefas de manipulação de PDFs, garantindo que seu código esteja protegido contra exceções de referência nula. Este exemplo demonstrou a sinergia entre uma poderosa biblioteca PDF e os recursos modernos da linguagem C#, permitindo que você escreva um código mais limpo e de mais fácil manutenção.

Lembre-se: a chave para usar essas ferramentas de forma eficaz está em compreender suas capacidades e aplicá-las criteriosamente em seus projetos.

A IronPDF oferece aos desenvolvedores um período de avaliação gratuito com suporte completo e atualizações , começando com uma licença lite.

Curtis Chau

Converse agora mesmo com a equipe de engenharia.

Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.

...