Try/Catch em C# (Como funciona para desenvolvedores)

O que são exceções e por que tratá-las?

Em C#, uma exceção representa uma ocorrência que acontece durante a execução de um programa e que interfere no fluxo normal de execução de instruções. Quando ocorre uma exceção, o fluxo do programa é desviado e, se a exceção não for tratada, o programa será encerrado abruptamente.

O tratamento de exceções é uma forma de antecipar e gerenciar esses eventos disruptivos, permitindo que seu programa se recupere de problemas inesperados e continue funcionando conforme o esperado. Ao usar blocos try e catch, você garante que seu código lide com erros de forma adequada e forneça aos usuários um feedback significativo.

O bloco Try

Um bloco try é um segmento de código que você espera que possa gerar exceções. Ao envolver seu código em um bloco try, você está dizendo ao compilador que deseja tratar possíveis exceções que possam surgir dentro desse bloco.

Aqui está um exemplo básico de como usar um bloco 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

Bloco Catch para capturar exceções

A instrução catch é usada em conjunto com um bloco try para lidar com exceções. Quando ocorre uma exceção dentro de um bloco try, a execução do programa salta para o bloco catch apropriado, onde você pode especificar o que o programa deve fazer em resposta à exceção.

Para capturar uma exceção, você precisa criar um bloco catch imediatamente após o bloco try. Um bloco catch normalmente inclui um parâmetro que representa a exceção capturada.

Eis um exemplo de uma declaração de captura em ação:

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

Neste exemplo, o código dentro do bloco try tenta dividir por zero, o que irá gerar um DivideByZeroException. O bloco catch então trata a exceção, exibindo uma mensagem para o usuário.

Vários blocos catch para lidar com diferentes exceções

Às vezes, seu bloco try pode gerar diferentes tipos de exceções possíveis. Nesses casos, você pode usar vários blocos catch para lidar com cada tipo de exceção separadamente.

O exemplo a seguir demonstra o uso de múltiplos blocos 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

Neste exemplo, o código dentro do bloco try tenta atribuir um valor a um índice de array que não existe, gerando um IndexOutOfRangeException. O primeiro bloco catch trata essa exceção específica, enquanto o segundo bloco catch captura qualquer outra exceção que possa ocorrer.

Lembre-se: ao usar vários blocos catch, sempre os ordene do tipo de exceção mais específico para o mais geral.

Filtros de exceção: adicionando condições aos blocos catch

Os filtros de exceção permitem adicionar condições aos blocos de captura, possibilitando a captura de exceções somente se uma determinada condição for atendida. Para usar um filtro de exceção, adicione a palavra-chave when seguida de uma condição em sua instrução catch.

O exemplo a seguir demonstra o uso de filtros de exceção:

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

No exemplo acima, o primeiro bloco catch tratará o erro DivideByZeroException somente se a mensagem de exceção contiver a palavra "divide". Caso a condição não seja atendida, o segundo bloco catch tratará a exceção.

O bloco finally garante a execução do código.

Em alguns casos, você pode querer garantir que um determinado trecho de código seja executado, independentemente de ocorrer ou não uma exceção. Para conseguir isso, você pode usar um bloco finally.

Um bloco finally é colocado após os blocos try e catch e é sempre executado, independentemente de ocorrer uma exceção.

Aqui está um exemplo que demonstra o uso de um bloco 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

No exemplo acima, mesmo que o código dentro do bloco try não gere uma exceção, o bloco finally ainda será executado.

Exceções personalizadas: adaptando as exceções às suas necessidades.

Às vezes, você pode querer criar suas próprias exceções personalizadas para lidar com exceções específicas em seu código. Para fazer isso, você pode criar uma nova classe que herde da classe Exception.

Aqui está um exemplo de como criar uma exceção 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

Agora, você pode usar essa exceção personalizada em seus blocos try e catch, assim:

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

Neste exemplo, o bloco try lança uma instância de CustomException, que é então capturada e tratada pelo bloco catch.

IronPDF: Integrando a funcionalidade de PDF com o tratamento de exceções.

Saiba mais sobre o IronPDF , uma biblioteca popular para criar, editar e extrair conteúdo de arquivos PDF em C#. Nesta seção, exploraremos como você pode integrar o IronPDF à sua abordagem de tratamento de exceções com bloco try-catch para lidar com possíveis erros de forma adequada.

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