Tratar exceções é de fundamental importância para que um programa não seja encerrado inesperadamente. Uma exceção pode acontecer durante o processamento do programa, quando algo inesperado acontece e deve ser tratado pelo programa, para que o mesmo não seja encerrado sem que o usuário saiba o que está acontecendo. Dois exemplos típicos de exceções:

• O programa tenta fazer uma leitura no disquete e não existe disquete no drive.
• Uma divisão por zero.

As exceções devem ser detectadas e opções devem ser oferecidas para o usuário do programa. Por exemplo, no caso do disquete que não está no drive, a exceção deve ser detectada e o programa deve exibir uma mensagem solicitando que o usuário insira um disquete no drive. Este procedimento é muito mais amigável do que simplesmente encerrar o programa.
Outra grande vantagem do Framework .NET é que o tratamento de exceções é padronizado, independentemente da linguagem que está sendo utilizada. Uma exceção gerada em um componente escrito em C++ pode ser tratada em um cliente escrito em C# e vice-versa.

Neste tópico veremos como tratar exceções em nossos programas C#.

Utilizando “try” e “catch”.

Para definir o tratamento de exceções em nossos programas precisamos organizar os códigos em um bloco try e um bloco catch. Dentro do bloco try colocamos o código que pode gerar uma exceção – por exemplo os comandos que farão a leitura de um arquivo no disquete e que, se o disquete não estiver no drive, será gerada uma seção. O código para o tratamento da exceção é colocado dentro do bloco catch.

Vamos apresentar um exemplo onde utilizamos try e catch para fazer o tratamento de exceções. O nosso programa solicita que o usuário digite dois números. Depois o programa faz a divisão dos números e exibe o resultado. Para forçar uma exceção vamos fornecer um valor zero para o segundo número, de tal forma que o programa, ao tentar fazer uma divisão por zero, irá gerar uma exceção.

Considere o exemplo da Listagem 5.8

using System;

class ex8cap5
                   {
                   // Exemplo 8 - Capítulo 5.
                   // Tratamento de exceções com try e catch.
                   // Por: Júlio Battisti
                   // MCP, MCP+I, MCSE, MCSE+I, MCSE, MCDBA

 public static void Main()
                   {

 // Início do bloco try.
                   // Contém o código que pode gerar a exceção.

 try

 {
                   // Declaração das variáveis.

 int divisao;

 // Entrada dos valores de x e y

 Console.Write("Digite o NUMERADOR ->");
                   String Aux1=Console.ReadLine();

 Console.Write("Digite o DENOMINADOR ->");
                   String Aux2=Console.ReadLine();

 // Cálculo da divisão.
                   divisao = Convert.ToInt32(Aux1) / Convert.ToInt32(Aux2);

 // Exibição dos resultados.
                   Console.WriteLine("O valor da DIVISÃO    é -> {0}",divisao);
                   }
                   // Final do bloco try.

 // Início do bloco catch.
                   // Código que será executado se uma exceção
                   // for gerada no bloco try.
   
                   catch (Exception e)

 {
                   Console.WriteLine("FOI GERADA A SEGUINTE EXCEÇÃO: " + e.Message);
                   } 

 // Final do bloco catch.
                   }
}

Listagem 5.8 – Tratamento de exceções com try e catch – ex8cap5.cs

Digite o exemplo da listagem 5.8 e salve o mesmo em um arquivo chamado ex8cap5.cs, na pasta C:\ExCsharp\cap5. Compile e execute o exemplo da listagem 5.8. Digite 10 para o numerador e 2 para o denominador. Você obterá os resultados indicados na Figura 5.10.

Figura 5.10 Executando, sem exceções, o programa ex8cap5.exe.

Observe que o programa executa normalmente. Agora vamos forçar uma exceção, para isso digitaremos 0 para o segundo valor, forçando uma divisão por zero. Vamos executar novamente o programa. Digite 10 para o primeiro valor e 0 para o segundo. Você obterá os resultados indicados na Figura 5.11.

Figura 5.11 Executando, forçando uma exceção, o programa ex8cap5.exe.

Neste segundo caso ao tentar fazer uma divisão por zero, uma exceção será gerada. Ao ser gerada a execução o código do bloco catch será executado. O bloco catch recebe um parâmetro do tipo Exception. Exception é uma classe do namespace System – System.Exception. Uma das propriedades desta classe é Message, a qual contém a mensagem associada com a exceção. No nosso exemplo a mensagem é: “Attempted to divide by zero”, o que confirma a nossa tentativa de fazer uma divisão por zero.

Existem classes que tratam exceções mais específicas, como por exemplo:

• System.OutOfMemoryException
• System.OverFlowException
• System.NullReferenceException
• System.NotSupportedException
• System.NotImplementedException
• System.NotFiniteNumberException
• System.MissingMethodException
• System.MissingMemberException
• System.MissingFieldException
• System.MethodAccessException
• System.MemberAccessException
• System.InvalidProgramException
• System.InvalidOperationException
• System.InvalidCastException
• System.IndexOutOfRangeException
• System.FormatException
• System.FieldAccessException
• System.ExecutionEngineException
• System.EntryPointNotFoundException
• System.DuplicateWaitObjectException
• System.DllNotFoundException
• System.DivideByZeroException

Vamos utilizar algumas destas classes nos demais capítulos deste livro.

Utilizando “try” e “finally”.

Em determinada situações queremos que um determinado bloco de código seja executado, mesmo que não tenha sido gerada nenhuma exceção. Para que isso seja possível podemos utilizar finally ao invés de catch. O código dentro do bloco finally é sempre executado, mesmo que não tenha sido gerada nenhuma exceção.

Vamos modificar um pouco o exemplo anterior.

Considere o exemplo da Listagem 5.9

using System;

class ex9cap5
{
                   // Exemplo 9 - Capítulo 5.
                   // Tratamento de exceções com try e finally.
                   // Por: Júlio Battisti
                   // MCP, MCP+I, MCSE, MCSE+I, MCSE, MCDBA

 public static void Main()
 {
                   // Bloco try.
                   // Contém o código que pode gerar a exceção.

 try

 {

 // Declaração das variáveis.

 int divisao;

 // Entrada dos valores de x e y

 Console.Write("Digite o NUMERADOR ->");
                   String Aux1=Console.ReadLine();

 Console.Write("Digite o DENOMINADOR ->");
                   String Aux2=Console.ReadLine();

 // Cálculo da divisão.

 divisao = Convert.ToInt32(Aux1) / Convert.ToInt32(Aux2);

 // Exibição dos resultados.
                     
                   Console.WriteLine("O valor da DIVISÃO    é -> {0}",divisao);
                   }
                   // Final do bloco try.

 // Início do bloco finally.
                   // Código que será executado mesmo que nenhuma exceção
                   // seja gerada no bloco try.
   
                   finally

 {
                   Console.WriteLine("CÓDIGO EXECUTADO TENHA OU NÃO SIDO GERADA UMA EXCEÇÃO");
                   } 

 // Final do bloco finally.
 }
}

Listagem 5.9 – Tratamento de exceções com try e finally – ex9cap5.cs

Digite o exemplo da listagem 5.9 e salve o mesmo em um arquivo chamado ex9cap5.cs, na pasta C:\ExCsharp\cap5. Compile e execute o exemplo da listagem 5.9. Digite 10 para o numerador e 2 para o denominador. Você obterá os resultados indicados na Figura 5.12. Observe que o código do bloco finally foi executado, mesmo sem ter sido gerada nenhuma exceção.

Figura 5.12 Executando, sem exceções, o programa ex9cap5.exe.

Agora vamos forçar uma exceção, para isso digitaremos 0 para o segundo valor, forçando uma divisão por zero. Vamos executar novamente o programa. Digite 10 para o primeiro valor e 0 para o segundo. Na Figura 5.13 é aberta uma janela indicando que ocorreu uma exceção no programa.

Figura 5.13 Aviso que uma exceção foi gerada.

Neste caso, como não havia um bloco catch, a exceção não foi tratada. Por isso que surgiu a janela indicada na Figura 5.13. Dê um clique em OK para fechar a janela de aviso e observe que o código do bloco finally foi executado, mesmo tendo sido gerado uma exceção, conforme indicado pela Figura 5.14:

Figura 5.14 O código do bloco finally é sempre executado.

Mas se quisermos ter as duas coisas, ou seja:

• Código para tratamento de exceções.
• Código que sempre executa.

Neste caso temos que juntar os blocos catch e finally, em um arranjo conhecido como try – catch – finally. Vamos alterar o exemplo anterior para termos uma estrutura try – catch – finally, de tal forma que as exceções sejam tratadas e tenhamos um código que sempre executa no encerramento do programa.

Considere o exemplo da Listagem 5.10

using System;

class ex10cap5
{
                   // Exemplo10 - Capítulo 5.
                   // Tratamento de exceções com try - catch - finally.
                   // Por: Júlio Battisti
                   // MCP, MCP+I, MCSE, MCSE+I, MCSE, MCDBA

 public static void Main()
 {
                   // Bloco try.
                   // Contém o código que pode gerar a exceção.

 try

 {

 // Declaração das variáveis.

 int divisao;

 // Entrada dos valores de x e y

 Console.Write("Digite o NUMERADOR ->");
                   String Aux1=Console.ReadLine();

 Console.Write("Digite o DENOMINADOR ->");
                   String Aux2=Console.ReadLine();

 // Cálculo da divisão.

 divisao = Convert.ToInt32(Aux1) / Convert.ToInt32(Aux2);

 // Exibição dos resultados.
                     
                   Console.WriteLine("O valor da DIVISÃO    é -> {0}",divisao);
                   }
                   // Final do bloco try.
                 

 // Início do bloco catch.
                   // Código que será executado se uma exceção
                   // for gerada no bloco try.
   
                   catch (Exception e)

 {
                   Console.WriteLine("FOI GERADA A SEGUINTE EXCEÇÃO: " + e.Message);
                   } 

 // Final do bloco catch.

 // Início do bloco finally.
                   // Código que será executado mesmo que nenhuma exceção
                   // seja gerada no bloco try.
   
                   finally

 {
                   Console.WriteLine("CÓDIGO EXECUTADO TENHA OU NÃO SIDO GERADA UMA EXCEÇÃO");
                   } 

 // Final do bloco finally.
                 

 }
}

Listagem 5.9 – Tratamento de exceções com try – catch - finally – ex10cap5.cs

Digite o exemplo da listagem 5.10 e salve o mesmo em um arquivo chamado ex10cap5.cs, na pasta C:\ExCsharp\cap5. Compile e execute o exemplo da listagem 5.10. Digite 10 para o numerador e 2 para o denominador. Você obterá os resultados indicados na Figura 5.15. Observe que o código do bloco finally foi executado, mesmo sem ter sido gerada nenhuma exceção. Como não foi gerada exceção o código do bloco catch não foi executado.

Figura 5.15 Executando, sem exceções, o programa ex10cap5.exe.

Agora vamos forçar uma exceção, para isso digitaremos 0 para o segundo valor, forçando uma divisão por zero. Vamos executar novamente o programa. Digite 10 para o primeiro valor e 0 para o segundo. Na Figura 5.16 observamos que a exceção foi identificada e a mensagem respectiva foi emitida. Isto indica que o código do bloco catch foi executado e, portanto, a exceção foi tratada. Também podemos observar que o código do bloco finally foi executado, mesmo tendo sido gerada uma exceção.

Figura 5.16 Execução, com exceções, do porgrama ex10cap5.exe.