Pruebas en un entorno real
Pruebe en producción sin marcas de agua.
Funciona donde lo necesites.
Tratamiento de excepciones correctamente es esencial en C#. Este tutorial muestra cómo utilizar un bloque try-catch con varias cláusulas catch. Cubriremos cómo capturar múltiples tipos de excepciones, utilizar filtros de excepciones y asegurar que los recursos se limpian con finalidad. El objetivo es ayudarle a crear aplicaciones C# robustas y tolerantes a errores.
Si aprende a capturar varios tipos de excepciones, podrá adaptar las respuestas a problemas específicos, lo que mejorará la fiabilidad de su programa. También veremos cómo aplicar condiciones a los bloques de captura con la palabra clave when
, lo que permite una gestión de errores más precisa.
Esta guía le proporcionará los métodos para capturar excepciones y manejar errores comunes y complejos sin problemas en sus proyectos de codificación. También exploraremos IronPDF en el contexto de la gestión de excepciones.
El manejo de excepciones en C# es un método utilizado para manejar errores en tiempo de ejecución, prevenir la terminación abrupta de un programa y manejar situaciones inesperadas cuando ocurren durante la ejecución de un programa. Los componentes principales de la gestión de excepciones son los bloques try
, catch
y finally
.
El bloque try incluye código que podría provocar una excepción, mientras que el bloque catch se encarga de gestionar la excepción si se produce. El bloque finally
es opcional y ejecuta código después de los bloques try
y catch
, independientemente de si se ha lanzado una excepción o no. He aquí una estructura sencilla:
try {
// Code that may throw an exception
}
catch (Exception e) {
// Code to handle the exception
}
finally {
// Code that executes after try and catch, regardless of an exception
}
try {
// Code that may throw an exception
}
catch (Exception e) {
// Code to handle the exception
}
finally {
// Code that executes after try and catch, regardless of an exception
}
Try
' Code that may throw an exception
Catch e As Exception
' Code to handle the exception
Finally
' Code that executes after try and catch, regardless of an exception
End Try
En aplicaciones reales, una misma operación puede lanzar excepciones de varios tipos. Para solucionar este problema, C# permite definir varios bloques catch
para un único bloque try
. Cada bloque catch puede especificar un tipo de excepción diferente para manejar todas las excepciones.
La captura de múltiples excepciones es esencial para la gestión detallada de errores, donde las acciones dependen del error específico que se haya producido. Permite a los desarrolladores gestionar cada excepción de forma adecuada al contexto de ese error concreto.
He aquí un ejemplo de cómo implementar un único bloque catch para capturar múltiples tipos de excepción:
try {
// Code that may throw multiple types of exceptions
int[] numbers = {1, 2, 3};
Console.WriteLine(numbers[5]); // This will throw an IndexOutOfRangeException
}
catch (IndexOutOfRangeException ex) {
Console.WriteLine("An index was out of range: " + ex.Message);
}
catch (DivideByZeroException ex) {
Console.WriteLine("Can't divide by Zero: " + ex.Message);
}
catch (Exception ex) {
Console.WriteLine("Error: " + ex.Message);
}
try {
// Code that may throw multiple types of exceptions
int[] numbers = {1, 2, 3};
Console.WriteLine(numbers[5]); // This will throw an IndexOutOfRangeException
}
catch (IndexOutOfRangeException ex) {
Console.WriteLine("An index was out of range: " + ex.Message);
}
catch (DivideByZeroException ex) {
Console.WriteLine("Can't divide by Zero: " + ex.Message);
}
catch (Exception ex) {
Console.WriteLine("Error: " + ex.Message);
}
Try
' Code that may throw multiple types of exceptions
Dim numbers() As Integer = {1, 2, 3}
Console.WriteLine(numbers(5)) ' This will throw an IndexOutOfRangeException
Catch ex As IndexOutOfRangeException
Console.WriteLine("An index was out of range: " & ex.Message)
Catch ex As DivideByZeroException
Console.WriteLine("Can't divide by Zero: " & ex.Message)
Catch ex As Exception
Console.WriteLine("Error: " & ex.Message)
End Try
En este código, excepciones específicas como IndexOutOfRangeException
y DivideByZeroException
son capturadas por sus respectivos bloques catch
. Cualquier otro tipo de excepción es capturada por el bloque genérico Exception
.
C# también admite filtros de excepciones que permiten especificar una condición dentro del bloque catch. Esta función utiliza la palabra clave when
para proporcionar más control sobre qué excepciones atrapar en función de la condición evaluada en tiempo de ejecución.
A continuación se explica cómo utilizar la palabra clave when
para añadir filtros de excepción:
try {
// Code that may throw an exception
throw new InvalidOperationException("Invalid operation occurred", new Exception("Inner exception"));
}
catch (Exception ex) when (ex.InnerException != null) {
Console.WriteLine("Exception with inner exception caught: " + ex.Message);
}
catch (Exception ex) {
Console.WriteLine("Exception caught: " + ex.Message);
}
try {
// Code that may throw an exception
throw new InvalidOperationException("Invalid operation occurred", new Exception("Inner exception"));
}
catch (Exception ex) when (ex.InnerException != null) {
Console.WriteLine("Exception with inner exception caught: " + ex.Message);
}
catch (Exception ex) {
Console.WriteLine("Exception caught: " + ex.Message);
}
Try
' Code that may throw an exception
Throw New InvalidOperationException("Invalid operation occurred", New Exception("Inner exception"))
Catch ex As Exception When ex.InnerException IsNot Nothing
Console.WriteLine("Exception with inner exception caught: " & ex.Message)
Catch ex As Exception
Console.WriteLine("Exception caught: " & ex.Message)
End Try
El bloque finally
se utiliza para ejecutar código una vez que se han completado los bloques try
y catch
. Es útil para limpiar recursos, como cerrar flujos de archivos o conexiones a bases de datos, independientemente de si se ha producido una excepción.
try {
// Code that might throw an exception
}
catch (Exception e) {
// Handle the exception
}
finally {
// Cleanup code, executed after try/catch
Console.WriteLine("Cleanup code runs here.");
}
try {
// Code that might throw an exception
}
catch (Exception e) {
// Handle the exception
}
finally {
// Cleanup code, executed after try/catch
Console.WriteLine("Cleanup code runs here.");
}
Try
' Code that might throw an exception
Catch e As Exception
' Handle the exception
Finally
' Cleanup code, executed after try/catch
Console.WriteLine("Cleanup code runs here.")
End Try
IronPDF es una completa biblioteca diseñada para desarrolladores C# que trabajan con aplicaciones .NET. Ayuda a los desarrolladores a manipular, gestionar y crear archivos PDF directamente a partir de HTML. No requiere la dependencia externa para funcionar.
Puede realizar cualquier operación en PDF sin necesidad de utilizar e instalar Adobe Acrobat. IronPDF admite varias funciones de PDF, como editar, combinar, dividir y proteger documentos PDF con cifrado y firmas digitales. Los desarrolladores pueden utilizar IronPDF en múltiples tipos de aplicaciones, incluidas aplicaciones web, aplicaciones de escritorio y servicios.
Interlink:
La característica clave de IronPDF es convertir HTML a PDF, que conserva tanto el diseño como el estilo. Es perfecto para producir PDFs a partir de contenido web, ya sea para informes, facturas o documentación. Los archivos HTML, las URLs y las cadenas HTML se pueden convertir en 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
Friend Class Program
Shared Sub Main(ByVal 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 Class
He aquí un sencillo ejemplo en C# que utiliza IronPDF para crear un PDF a partir de HTML, con gestión de errores para múltiples tipos de excepciones. Este ejemplo asume que usted tiene IronPDF instalado en su proyecto. Ejecute este comando en la consola NuGet para instalar IronPDF:
Install-Package IronPdf
Aquí está el código:
using IronPdf;
using System;
class Program
{
static void Main(string[] args)
{
License.LicenseKey = "License-Key";
var renderer = new ChromePdfRenderer();
try
{
// Convert HTML to PDF
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
pdf.SaveAs("Exceptions.pdf");
Console.WriteLine("PDF successfully created.");
}
catch (IronPdf.Exceptions.IronPdfProductException ex)
{
// Handle PDF generation errors
Console.WriteLine("Failed to generate PDF: " + ex.Message);
}
catch (System.IO.IOException ex)
{
// Handle IO errors (e.g., disk I/O errors)
Console.WriteLine("IO Exception: " + ex.Message);
}
catch (Exception ex)
{
// Handle other errors
Console.WriteLine("Error" + ex.Message);
}
}
}
using IronPdf;
using System;
class Program
{
static void Main(string[] args)
{
License.LicenseKey = "License-Key";
var renderer = new ChromePdfRenderer();
try
{
// Convert HTML to PDF
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
pdf.SaveAs("Exceptions.pdf");
Console.WriteLine("PDF successfully created.");
}
catch (IronPdf.Exceptions.IronPdfProductException ex)
{
// Handle PDF generation errors
Console.WriteLine("Failed to generate PDF: " + ex.Message);
}
catch (System.IO.IOException ex)
{
// Handle IO errors (e.g., disk I/O errors)
Console.WriteLine("IO Exception: " + ex.Message);
}
catch (Exception ex)
{
// Handle other errors
Console.WriteLine("Error" + ex.Message);
}
}
}
Imports IronPdf
Imports System
Friend Class Program
Shared Sub Main(ByVal args() As String)
License.LicenseKey = "License-Key"
Dim renderer = New ChromePdfRenderer()
Try
' Convert HTML to PDF
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>")
pdf.SaveAs("Exceptions.pdf")
Console.WriteLine("PDF successfully created.")
Catch ex As IronPdf.Exceptions.IronPdfProductException
' Handle PDF generation errors
Console.WriteLine("Failed to generate PDF: " & ex.Message)
Catch ex As System.IO.IOException
' Handle IO errors (e.g., disk I/O errors)
Console.WriteLine("IO Exception: " & ex.Message)
Catch ex As Exception
' Handle other errors
Console.WriteLine("Error" & ex.Message)
End Try
End Sub
End Class
Cuando ejecutamos este código, aparece este mensaje en la línea de comandos.
Y es el archivo PDF generado por este código:
Asegúrese de probar esto en un entorno en el que IronPDF esté correctamente configurado, y modifique el contenido HTML según sea necesario para su aplicación. Esto le ayudará a gestionar los errores de forma eficaz, mejorando la fiabilidad de sus tareas de generación de PDF.
El manejo de múltiples excepciones en C# es una potente función que proporciona sólidas capacidades de gestión de errores en sus aplicaciones. Mediante el uso de múltiples bloques catch
, filtros de excepción, y el bloque finally
, puede crear una aplicación resistente y estable que maneja diferentes errores con gracia y mantiene su integridad bajo diversas condiciones de error.
Este conocimiento exhaustivo y la implementación de la gestión de múltiples excepciones garantizan que sus aplicaciones estén bien preparadas para hacer frente a situaciones inesperadas con eficacia. IronPDF ofrece un prueba gratuita comienza a partir de $749.
9 productos API .NET para sus documentos de oficina