C# Catch Multiple Exceptions (Cómo Funciona Para Desarrolladores)

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.

¿Qué es 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.

Estructura básica de Try-Catch en C#

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

Captura de múltiples excepciones

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.

¿Por qué atrapar varias 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.

Cómo implementar varios bloques de captura

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.

Uso de filtros de excepción con la palabra clave When

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 papel del bloque por fin

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

Presentación de IronPDF

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.

Ejemplo de código

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.

Conclusión

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.