Try/Catch en C# (Cómo funciona para desarrolladores)

¿Qué son las excepciones y por qué manejarlas?

En C#, una excepción representa un evento que ocurre mientras un programa se está ejecutando, lo que interfiere con la progresión estándar del programa al ejecutar instrucciones. Cuando ocurre una excepción, el flujo del programa se desvía, y si la excepción no se maneja, el programa terminará abruptamente.

El manejo de excepciones es una forma de anticipar y gestionar estos eventos disruptivos, permitiendo que tu programa se recupere de problemas inesperados y continúe ejecutándose como se esperaba. Usando bloques try y catch, puedes asegurar que tu código maneje los errores de manera elegante y proporcione a los usuarios retroalimentación significativa.

El bloque de prueba

Un bloque try es un segmento de código que esperas que pueda generar excepciones. Cuando envuelves tu código en un bloque try, le estás diciendo al compilador que deseas manejar las excepciones potenciales que puedan surgir dentro de ese bloque.

Aquí hay un ejemplo básico de cómo usar un bloque try:

try
{
    // Code that may generate an exception
}
catch (Exception ex)
{
    // Handle the exception
}

try
{
    // Code that may generate an exception
}
catch (Exception ex)
{
    // Handle the exception
}

Try
	' Code that may generate an exception
Catch ex As Exception
	' Handle the exception
End Try

Bloque de captura de excepciones

La declaración catch se usa junto con un bloque try para manejar excepciones. Cuando ocurre una excepción dentro de un bloque try, la ejecución del programa salta al bloque catch correspondiente, donde puedes especificar lo que el programa debe hacer en respuesta a la excepción.

Para capturar una excepción, necesitas crear un bloque catch inmediatamente después del bloque try. Un bloque catch típicamente incluye un parámetro que representa la excepción capturada.

Aquí hay un ejemplo de una declaración catch en acción:

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}

Try
	Dim result As Integer = 10 \ 0
Catch ex As DivideByZeroException
	Console.WriteLine("An error occurred: " & ex.Message)
End Try

En este ejemplo, el código dentro del bloque try intenta dividir por cero, lo que generará una DivideByZeroException. El bloque catch luego maneja la excepción, mostrando un mensaje al usuario.

Múltiples Bloques de Captura que Manejan Diferentes Excepciones

A veces, tu bloque try puede generar diferentes tipos de excepciones posibles. En tales casos, puedes usar múltiples bloques catch para manejar cada tipo de excepción por separado.

El siguiente ejemplo demuestra el uso de múltiples bloques catch:

try
{
    int[] numbers = new int[7];
    numbers[12] = 70; // This line will throw an exception
}
catch (IndexOutOfRangeException ex)
{
    Console.WriteLine("An index out of range error occurred: " + ex.Message);
}
catch (Exception e)
{
    Console.WriteLine("An unexpected error occurred: " + e.Message);
}

try
{
    int[] numbers = new int[7];
    numbers[12] = 70; // This line will throw an exception
}
catch (IndexOutOfRangeException ex)
{
    Console.WriteLine("An index out of range error occurred: " + ex.Message);
}
catch (Exception e)
{
    Console.WriteLine("An unexpected error occurred: " + e.Message);
}

Try
	Dim numbers(6) As Integer
	numbers(12) = 70 ' This line will throw an exception
Catch ex As IndexOutOfRangeException
	Console.WriteLine("An index out of range error occurred: " & ex.Message)
Catch e As Exception
	Console.WriteLine("An unexpected error occurred: " & e.Message)
End Try

En este ejemplo, el código dentro del bloque try intenta asignar un valor a un índice de arreglo que no existe, generando una IndexOutOfRangeException. El primer bloque catch maneja esta excepción específica, mientras que el segundo bloque catch captura cualquier otra excepción que pueda ocurrir.

Recuerda, cuando uses múltiples bloques catch, ordénalos siempre de los tipos de excepción más específicos a los más generales.

Filtros de excepciones que añaden condiciones a los bloques de captura

Los filtros de excepciones te permiten añadir condiciones a los bloques catch, permitiéndote capturar excepciones solo si se cumple una cierta condición. Para usar un filtro de excepciones, añade la palabra clave when seguida de una condición en tu declaración catch.

El siguiente ejemplo demuestra el uso de filtros de excepciones:

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex) when (ex.Message.Contains("divide"))
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("A different divide by zero error occurred: " + ex.Message);
}

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex) when (ex.Message.Contains("divide"))
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("A different divide by zero error occurred: " + ex.Message);
}

Try
	Dim result As Integer = 10 \ 0
Catch ex As DivideByZeroException When ex.Message.Contains("divide")
	Console.WriteLine("An error occurred: " & ex.Message)
Catch ex As DivideByZeroException
	Console.WriteLine("A different divide by zero error occurred: " & ex.Message)
End Try

En el ejemplo anterior, el primer bloque catch manejará la DivideByZeroException solo si el mensaje de la excepción contiene la palabra "divide". Si la condición no se cumple, el segundo bloque catch manejará la excepción.

El bloque Finally garantiza la ejecución del código

En algunos casos, puede que quieras asegurarte de que un fragmento de código en particular se ejecute, ocurra o no una excepción. Para lograr esto, puedes usar un bloque finally.

Un bloque finally se coloca después de los bloques try y catch y siempre se ejecuta, independientemente de si ocurre una excepción.

Aquí hay un ejemplo que muestra el uso de un bloque finally:

try
{
    int result = 10 / 2;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
finally
{
    Console.WriteLine("This line will always be executed.");
}

try
{
    int result = 10 / 2;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
finally
{
    Console.WriteLine("This line will always be executed.");
}

Try
	Dim result As Integer = 10 \ 2
Catch ex As DivideByZeroException
	Console.WriteLine("An error occurred: " & ex.Message)
Finally
	Console.WriteLine("This line will always be executed.")
End Try

En el ejemplo anterior, incluso si el código dentro del bloque try no genera una excepción, el bloque finally aún se ejecutará.

Excepciones personalizadas: Cómo adaptar las excepciones a sus necesidades

A veces, puede que desees crear tus propias excepciones personalizadas para manejar excepciones específicas en tu código. Para hacer esto, puedes crear una nueva clase que herede de la clase Exception.

Aquí hay un ejemplo de creación de una excepción personalizada:

public class CustomException : Exception
{
    public CustomException(string errorMessage) : base(errorMessage)
    {
    }
}

public class CustomException : Exception
{
    public CustomException(string errorMessage) : base(errorMessage)
    {
    }
}

Public Class CustomException
	Inherits Exception

	Public Sub New(ByVal errorMessage As String)
		MyBase.New(errorMessage)
	End Sub
End Class

Ahora, puedes usar esta excepción personalizada en tus bloques try y catch, como esto:

try
{
    throw new CustomException("This is a custom exception.");
}
catch (CustomException ex)
{
    Console.WriteLine("A custom exception occurred: " + ex.Message);
}

try
{
    throw new CustomException("This is a custom exception.");
}
catch (CustomException ex)
{
    Console.WriteLine("A custom exception occurred: " + ex.Message);
}

Try
	Throw New CustomException("This is a custom exception.")
Catch ex As CustomException
	Console.WriteLine("A custom exception occurred: " & ex.Message)
End Try

En este ejemplo, el bloque try lanza una instancia de CustomException, que luego es capturada y manejada por el bloque catch.

IronPDF: Integración de la funcionalidad PDF con el manejo de excepciones

Aprende Más Sobre IronPDF es una biblioteca popular para crear, editar y extraer contenido de archivos PDF en C#. En esta sección, exploraremos cómo puedes integrar IronPDF con tu enfoque de manejo de excepciones try-catch para manejar errores potenciales de manera elegante.

Install-Package IronPdf

using IronPdf;
using System;

try
{
    var renderer = new ChromePdfRenderer();
    string html = "Hello, World!";
    PdfDocument PDF = renderer.RenderHtmlAsPdf(html);
    PDF.SaveAs("output.PDF");
    Console.WriteLine("PDF created successfully.");
}
catch (Exception ex)
{
    Console.WriteLine("An unexpected error occurred: " + ex.Message);
}

using IronPdf;
using System;

try
{
    var renderer = new ChromePdfRenderer();
    string html = "Hello, World!";
    PdfDocument PDF = renderer.RenderHtmlAsPdf(html);
    PDF.SaveAs("output.PDF");
    Console.WriteLine("PDF created successfully.");
}
catch (Exception ex)
{
    Console.WriteLine("An unexpected error occurred: " + ex.Message);
}

Imports IronPdf
Imports System

Try
	Dim renderer = New ChromePdfRenderer()
	Dim html As String = "Hello, World!"
	Dim PDF As PdfDocument = renderer.RenderHtmlAsPdf(html)
	PDF.SaveAs("output.PDF")
	Console.WriteLine("PDF created successfully.")
Catch ex As Exception
	Console.WriteLine("An unexpected error occurred: " & ex.Message)
End Try

using IronPdf;
using System;
using System.IO;

try
{
    string pdfPath = "input.PDF";
    if (File.Exists(pdfPath))
    {
        PdfDocument PDF = PdfDocument.FromFile(pdfPath);
        string extractedText = PDF.ExtractAllText();
        Console.WriteLine("Text extracted successfully: " + extractedText);
    }
    else
    {
        Console.WriteLine("The specified PDF file does not exist.");
    }
}
catch (Exception ex)
{
    Console.WriteLine("An unexpected error occurred: " + ex.Message);
}

using IronPdf;
using System;
using System.IO;

try
{
    string pdfPath = "input.PDF";
    if (File.Exists(pdfPath))
    {
        PdfDocument PDF = PdfDocument.FromFile(pdfPath);
        string extractedText = PDF.ExtractAllText();
        Console.WriteLine("Text extracted successfully: " + extractedText);
    }
    else
    {
        Console.WriteLine("The specified PDF file does not exist.");
    }
}
catch (Exception ex)
{
    Console.WriteLine("An unexpected error occurred: " + ex.Message);
}

Imports IronPdf
Imports System
Imports System.IO

Try
	Dim pdfPath As String = "input.PDF"
	If File.Exists(pdfPath) Then
		Dim PDF As PdfDocument = PdfDocument.FromFile(pdfPath)
		Dim extractedText As String = PDF.ExtractAllText()
		Console.WriteLine("Text extracted successfully: " & extractedText)
	Else
		Console.WriteLine("The specified PDF file does not exist.")
	End If
Catch ex As Exception
	Console.WriteLine("An unexpected error occurred: " & ex.Message)
End Try