Uma exceção, é um evento ou acontecimento não desejado que pode ocorrer durante a execução de nossos programas, como erros de acesso a memória, falhas ao abrir um arquivo e outros. Quando esse evento acontece, um objeto contendo as informações do erro é lançado para que o tratamento seja feito.

Diferente de Java, a linguagem C# não possui um comando throws para informar que um método irá lançar determinadas exceções, e devem ser chamados dentro do bloco try.

Para lançarmos uma exceção em C#, precisamos utilizar a palavra reservada throw seguida de um objeto que informa o tipo da exceção desejada.

Sintaxe

try
{
  throw new tipo_excecao(mensagem); //instância de exceção
}
catch(tipo_excecao obj)
{
  //tratamento
}

Onde

mensagem: string contendo a mensagem de erro customizada para informação

Exemplo 1

using System;
					
public class Program
{
	public static void Main()
	{
		try
		{
			throw new NullReferenceException();
		}
		catch(NullReferenceException e)
		{
			Console.WriteLine("NullReferenceException");
		}
	}
}

Saída

NullReferenceException

Quando uma exceção ocorre, precisamos obter algumas informações básicas como: a mensagem do erro e onde o erro ocorreu. As exceções em C# possuem as propriedades herdadas de Exception e estão listadas na tabela abaixo:

Exemplo 1

using System;
public class Program
{
	public static void Main()
	{
		try
		{
			throw new NullReferenceException("uma mensagem de erro qualquer");
		}
		catch(NullReferenceException e)
		{
			Console.WriteLine("Message:{0}",e.Message);
			Console.WriteLine("TargetSite:{0}",e.TargetSite);
			Console.WriteLine("StackTrace:{0}",e.StackTrace);
		}
	}
}

Saída

Message:uma mensagem de erro qualquer
TargetSite:Void Main()
StackTrace:   at Program.Main() in d:\Windows\Temp\rirt2ncy.0.cs:line 9

O StackTrace armazena todas as chamadas a métodos feitas em nossos programas, até à linha em que uma exceção foi lançada. Por ser uma Stack(Pilha), as chamadas são empilhadas umas sobres as outras, sendo a linha que lançou uma exceção a última.

Exemplo 3

public class Program
{
    public static void metodo1()
    {
        metodo2();
    }
    
    public static void metodo2()
    {
        metodo3();
    }
    public static void metodo3()
    {
         throw new NullReferenceException("Análisando stacktrace");
    }

	public static void Main()
	{
		try
		{
			metodo1();
		}
		catch(NullReferenceException e)
		{
			Console.WriteLine("StackTrace:{0}",e.StackTrace);
		}
	}
}

Saída

StackTrace:   at Program.metodo3() in d:\Windows\Temp\main.cs:line 12
   at Program.metodo2() in d:\Windows\Temp\main.cs:line 9
   at Program.metodo1() in d:\Windows\Temp\main.cs:line 5
   at Program.Main() in d:\Windows\Temp\main.cs:line 19

Como podemos observar na saída acima, podemos verificar a ordem de chamada dos métodos até que uma exceção seja lançada mostrando a importância do StackTrace na investigação de erros.

No exemplo anterior, utilizamos o comando throw para lançar uma exceção explicitamente. Em alguns momentos, o tratamento da exceção não pode, por algum motivo, ser tratado em seu respectivo bloco catch. Nesse caso, podemos relançar uma exceção para um escopo acima do atual, utilizando também o throw.

Sintaxe

try
{
    //código
}
catch(classe_excecao objeto ) 
{
    throw objeto; //relançando exceção
}

Exemplo 5

using System;
public class Program
{  
	public static void metodo()
	{
		try
		{
			int a=1,b=0;
			int c = a/b;
		}
		catch(Exception ex)
		{
			throw ex; //relançando exceção
		}
	}
	
	public static void Main() 
	{
        try
        {
			metodo();
        }
        catch(DivideByZeroException e )
        {
            Console.WriteLine(e.Message);
        }
	}
}

Saída

attempt to divide by zero

Caso uma nova exceção seja lançada com uma nova ins~tância ao invés de relançada, as informações do StackTrace referentes ao erro anterior serão perdidos, "mascarando" o erro, o que pode vir a dificultar a descoberta de sua origem.

Neste tópico ficarão listadas alguns boas práticas em relação ao uso de exceptions em nossos programas. Essas boas práticas devem ser levadas em consideração durante o desenvolvimento de aplicações. Mais boas práticas serão adicionadas em futuras atualizações.

Validação de dados

As exceptions não devem ser utilizadas para situações comuns de validação de dados. Esses devem ser validadas utilizando comandos de decisão, por exemplo, e tratados corretamente para evitando o uso exceções.

Relançar Exception

Não relance exceptions dentro de blocos finally e construtores de classe.

Exception customizada

Verique se o .NET possui exceptions que possam ser utilizadas antes de criar nossas próprias exceptions. Criando exceptions próprias podemos realizar o tratamento nos blocos catch de forma mas precisa.

Bloco catch-finally

Utilize sempre o bloco finally que foi estudado em Try-Catch para liberar os recursos utilizados mesmo ocorrendo um erro.

Os métodos que realizam lógicas complexas devem ser executados de forma atômica, ou seja, caso exception ocorra, o processo de ser desfeito para evitar inconsistências nos dados da aplicação.

Mensagens de erro

As mensagens de erro para o usuário devem ser amigáveis sem detalhes técnicos. Para os devenvolvedores devem ser detalhadas em logs com informações do erro, stacktrace e outros.

1. 13/08/2025 - revisão 2 - Ajustes: pontuais, sintaxes e 'Objetivos'; Adição: Uso de Exceptions
2. 10/10/2024 - revisão 1 - Correções e ajustes pontuais
3. 18/03/2024 - versão inicial