¿Qué es el operador condicional nulo de C#?

El operador condicional nulo de C#, también conocido como el 'operador Elvis' (?.), permite a los desarrolladores acceder a miembros o métodos solo si el objeto no es nulo, previniendo excepciones de referencia nula y simplificando el manejo de valores nulos.

¿Cómo puede el operador condicional nulo de C# mejorar la legibilidad del código?

Al reducir el número de comprobaciones nulas explícitas necesarias, el operador condicional nulo de C# hace que el código sea más limpio y legible, permitiendo a los desarrolladores centrarse en la lógica central en lugar de en la validación nula.

¿Puede el operador condicional nulo usarse con el operador de coalescencia nula?

Sí, el operador condicional nulo puede combinarse con el operador de coalescencia nula (??) para proporcionar un valor predeterminado cuando una expresión se evalúa como nula, mejorando la robustez y seguridad del código.

¿Cómo afecta el operador condicional nulo a la seguridad en hilos?

Mejora la seguridad en hilos permitiendo el acceso seguro a recursos compartidos sin riesgo de excepciones de referencia nula, lo cual es crucial al trabajar con aplicaciones multihilo.

¿Cuáles son algunas aplicaciones prácticas del operador condicional nulo?

Las aplicaciones prácticas incluyen simplificar el manejo de eventos con sintaxis como PropertyChanged?.Invoke y acceder a elementos en colecciones de manera segura sin correr riesgo de excepciones de referencia nula.

¿Cómo se puede usar IronPDF para convertir HTML a PDF en C#?

IronPDF puede convertir HTML a PDF en C# usando métodos como RenderHtmlAsPdf para cadenas HTML o RenderHtmlFileAsPdf para archivos HTML, asegurando la preservación del estilo.

¿Cuál es el papel del operador condicional nulo en la generación de PDF con IronPDF?

El operador condicional nulo puede usarse para acceder de manera segura a las propiedades del documento PDF al generar PDFs con IronPDF, mejorando el manejo de valores nulos durante el proceso.

¿Cómo se instala IronPDF en un proyecto .NET?

IronPDF puede instalarse en un proyecto .NET mediante el Administrador de Paquetes NuGet usando el comando Install-Package IronPDF .

¿Qué beneficios ofrece el operador condicional nulo en el desarrollo de C#?

El operador condicional nulo reduce la complejidad del código, previene excepciones de referencia nula y mejora la mantenibilidad del código, lo que lo convierte en una herramienta valiosa para los desarrolladores de C#.

¿Puede utilizarse IronPDF con tipos anulables en C#?

Sí, IronPDF puede integrarse con tipos anulables en C# utilizando el operador condicional nulo para manejar valores nulos de manera elegante durante las operaciones de PDF.

La Biblioteca PDF de C#

Explore IronPDF Prueba gratis

HTML a PDF

Online Demo Ver Todos los Ejemplos 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

ACTUALIZACIONES PARA DESARROLLADORES

C# Operador Condicional Nulo (Cómo Funciona para Desarrolladores)

Jacob Mellor

Updated: 21 de abril de 2026

El operador condicional nulo de C# ofrece una manera más concisa y segura de manejar valores nulos en tu código. La belleza de este operador radica en su capacidad para simplificar las verificaciones de nulos, haciendo que tu código sea más limpio y fácil de leer.

Vamos a profundizar en los detalles de cómo funciona el null operador condicional, sus beneficios y cómo puedes utilizarlo en tus proyectos. También exploraremos IronPDF y sus casos de uso y su caso de uso con el operador condicional Null.

¿Qué es el operador condicional nulo?

El operador condicional nulo, a menudo llamado "operador Elvis" debido a su semejanza con el peinado de Elvis Presley (?.), te permite realizar acceso a miembros o llamadas a métodos en un objeto solo si ese objeto no es nulo.

Si el objeto es nulo, la operación devuelve nulo en lugar de lanzar una excepción de referencia nula. Este operador es un cambio de juego para los desarrolladores, ya que reduce significativamente la cantidad de código necesario para acceder de manera segura a miembros de objetos potencialmente nulos.

Los conceptos básicos de los operadores condicionales nulos

Para entender el operador condicional nulo, considera el ejemplo de public class Employee. Esta clase podría tener propiedades como public string FirstName y public string LastName. En código C# tradicional, acceder a una propiedad de un objeto Employee potencialmente nulo requiere verificaciones explícitas de nulo para evitar excepciones:

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

Sin embargo, con el operador condicional nulo, puedes simplificar esto a una línea:

var name = employee?.FirstName;

var name = employee?.FirstName;

Dim name = employee?.FirstName

Dim name = employee?.FirstName

Si employee no es nulo, la variable name recibe el valor de employee.FirstName. Si employee es nulo, name se establece en nulo. Esta única línea de código reemplaza elegantemente múltiples líneas de verificaciones de nulos explícitas.

Combinación con operadores de coalescencia nulos

El operador condicional nulo se vuelve aún más poderoso cuando se combina con el operador de coalescencia nula (??=). El operador de coalescencia nula te permite especificar un valor predeterminado en caso de que una expresión se evalúe como nula.

Por ejemplo, si quieres asegurarte de que la variable name tenga un valor por defecto de "Desconocido" en lugar de nulo, puedes escribir:

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 si employee es nulo y luego asigna "Desconocido" a name si employee.FirstName es nulo. Esto maneja elegantemente los valores nulos en una operación, mostrando cuán conciso y efectivo puede llegar a ser tu código.

C# introdujo tipos anulables, que permiten que las variables contengan un valor no nulo de su tipo subyacente o nulo.

Uso Avanzado: Condicional nulo y colecciones

Al trabajar con colecciones, el operador condicional nulo puede usarse para acceder a un elemento sin arriesgarse a una excepción de referencia nula. Supón que tienes una lista de empleados y quieres acceder de manera segura al nombre del primer elemento. Puedes usar el operador con corchetes:

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

Esta línea de código es segura para subprocesos, lo que significa que garantiza que si otro subproceso cambia employees a nulo después de la verificación de nulo pero antes de acceder a su primer elemento, tu código no fallará. Cuando se trata de tipos anulables, es importante entender su tipo de valor subyacente, que es el tipo no anulable asociado con el tipo anulable.

Seguridad de hilos y el operador condicional nulo

Una de las sutilezas de usar el operador condicional nulo es su característica de seguridad en el manejo de subprocesos. Cuando usas este operador, la evaluación de la expresión es segura para subprocesos. Esto significa que si estás accediendo a un recurso compartido que podría ser modificado por otro subproceso, el uso del operador condicional nulo puede prevenir potenciales condiciones de carrera.

Sin embargo, es importante entender que mientras el operador en sí es seguro para el subproceso de la operación que realiza, no garantiza la seguridad para subprocesos de todo tu bloque de código o secuencia de operaciones.

Ejemplo práctico

Consideremos un ejemplo más práctico donde tienes un objeto que podría producir un evento. En C# tradicional, verificarías si el manejador de eventos es nulo antes de invocar el evento para evitar una excepción de referencia 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

Con el operador condicional nulo, esto puede simplificarse a:

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 logra el mismo resultado, pero de una manera más legible y segura. En escenarios donde quieras devolver null explícitamente, puedes simplemente usar la sentencia return null;. El operador ?. corta la operación si PropertyChanged es nulo, evitando así una excepción. Aquí está el 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

Aquí está la salida del código:

Operador Condicional Nulo en C# (Cómo Funciona para Desarrolladores): Figura 1

Introducción a IronPDF en Proyectos C#

IronPDF es una biblioteca versátil para desarrolladores C# que te permite crear, editar y extraer contenido PDF dentro de aplicaciones .NET. Esta biblioteca destaca por su facilidad de uso y su capacidad para integrar de manera fluida funcionalidades PDF en cualquier proyecto .NET.

La principal característica de IronPDF es convertir HTML a PDF con preservación completa del estilo, con preservación completa del diseño y estilo. Es una gran solución para generar PDFs a partir de contenido web, incluidos informes, facturas y documentación. Admite la conversión de archivos HTML, URLs y cadenas HTML a archivos 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

Ya sea que estés generando informes, facturas o cualquier documento en formato PDF, IronPDF proporciona un conjunto completo de herramientas para completar estas tareas de manera eficiente.

Integración de IronPDF con operadores condicionales nulos

Integrar IronPDF en tu proyecto para manejar PDFs junto con operadores condicionales nulos puede mejorar significativamente la robustez de tu aplicación. Esta combinación es particularmente útil cuando se trata con contenido PDF que podría ser nulo o al realizar operaciones que podrían resultar potencialmente en un valor nulo.

Exploremos un ejemplo simple donde usamos IronPDF para generar un documento PDF a partir de contenido HTML. Luego usaremos el operador condicional nulo para acceder de manera segura a las propiedades del documento, ilustrando cómo manejar graciosamente los valores nulos.

Instalación de IronPDF

Primero, necesitas añadir IronPDF a tu proyecto. Puedes hacerlo a través del Administrador de Paquetes NuGet:

PM > Install-Package IronPdf

Install-Package IronPdf

Ahora escribe el siguiente código en el archivo 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

Resultado

Aquí está la salida de la consola cuando ejecutas el programa:

Operador Condicional Nulo en C# (Cómo Funciona para Desarrolladores): Figura 2

Y este es el PDF generado por el programa:

Operador Condicional Nulo en C# (Cómo Funciona para Desarrolladores): Figura 3

Conclusión

Integrar IronPDF con operadores condicionales nulos en tus proyectos C# puede optimizar significativamente tus tareas de manejo de PDF al mismo tiempo que garantiza que tu código esté a salvo de excepciones de referencia nula. Este ejemplo demostró la sinergia entre una poderosa biblioteca PDF y las características modernas del lenguaje C#, lo que te permite escribir un código más limpio y mantenible.

Recuerda, la clave para usar efectivamente estas herramientas es entender sus capacidades y aplicarlas prudentemente en tus proyectos.

IronPDF ofrece a los desarrolladores una prueba gratuita con soporte completo y actualizaciones, comenzando con una licencia ligera.

Jacob Mellor

Chatea con el equipo de ingeniería ahora

Director de Tecnología

Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.

...