Quando desenvolvemos um
sistema, não basta ele apenas está com as regras de negócios
consistentes, com um layout que agrade ao cliente etc. Ele também tem que está
preparado para tratar exceções que ocorreram, nenhum sistema é anti-exceções,
em algum momento qualquer sistema terá que tratar uma exceção, e é melhor ele
está preprado para isso ou o usuário poderá ter uma exceção em tempo de
execução que pode encerrar o seu sistema de forma inesperada ou gerar uma
mensagem incompreensível.
Instruções
do C# para tratamento de exceções
As instruções
utilizadas pelo C# para tratamento de exceções estão listadas abaixo:
|
Instrução
|
Descrição
|
|
try
|
Bloco onde pode
ocorrer o erro.
|
|
catch
|
Bloco onde será
tratado o erro.
|
|
finally
|
Essa instrução é
sempre executada, muito útil quando queremos liberar um recurso
independentemente se ocorrer erro ou não.
|
|
throw
|
Podemos utilizar essa
instrução para gerar a nossas próprias exceções.
|
Instruções
try e catch
Utilizamos as
instruções try e catch para o tratamento estruturado de exceções, a sua sintaxe
está listada abaixo:
try{
//Código onde pode ocorrer a exceção
}
catch{
//Código onde será tratada a exceção
}
Exemplo:
try{
int i = 0;
Console.WriteLine(10 / i);
}
catch
{
Console.WriteLine("Ocorreu
uma exceção");
}
No exemplo acima o tratamento de erro
está funcionando, mas ele não está funcional, porque não nós oferece detalhes
sobre a exceção ocorrida, o C# contém uma séries de classes para manipulação de
exceções e é sempre uma boa prática utilizamos essas classes.
Utilizando a classe
DivideByZeroException no nosso exemplo anterior, vejamos como fica o nosso
exemplo:
try{
int i = 0;
Console.WriteLine(10 / i);
}
catch(DivideByZeroException ex){
Console.WriteLine(ex.Message);
}
Percebemos que com a utilização da
classe DivideByZeroException, podemos fazer o tratamento da exceção de uma
maneira mais detalhada, pois, sabemos qual o tipo de exceção que temos que
tratar, é sempre uma boa prática utilzamos as classes para manipulação de
exceção do C#.
Também
podemos utilizar multiplas instruções catch com o try, quando temos um bloco
que pode ocorrer mais de uma exceção, utilizamos multiplas instruções catch
para tratar mais de uma exceção.
Exemplo:
try{
int i = 0;
Console.WriteLine(10 / i);
}
catch
(DivideByZeroException ex){
Console.WriteLine(ex.Message);
}
catch(Exception ex){
Console.WriteLine(ex.Message);
}
No exemplo acima utilizamos multiplas
instruções catch, caso ocorra uma exceção diferente da que dividimos um número
por zero, a exceção será tratada pela classe Exception, que é utilizada para
tratar exceções de uma forma generica.
É sempre uma boa prática quando
utilizamos multiplas instruções catch fazemos o tratamento de exceções sempre
utilizando as classes especificas primeiro e somente por fim a classe
Exception.
Instruções
finally
A instrução finally
sempre é executada, ou seja, o código que estiver no bloco finally sempre será
executado, independentemente se ocorre uma exceção ou não, a instrução finally
é muito útil quando queremos liberar algum recurso utilizado, como um arquivo
ou uma conexão com um banco de dados, a sua sintaxe está listada abaixo:
try{
//Código onde pode ocorrer a exceção
}
finally
{
//Código que será executado independemente de exceção ou não
}
Podemos utilizar apenas
as instruções try e finally ou try, catch e finally.
try{
//Código onde pode ocorrer a exceção
}
catch{
//Código onde será tratada a exceção
}
finally
{
//Código que será executado independemente de exceção ou não
}
Exemplo:
try{
StreamReader arq = new
StreamReader("exemplo.txt");
try{
String linha;
while ((linha = arq.ReadLine()) != null){
Console.WriteLine(linha);
}
}
finally{
arq.Dispose();
}
}
catch (Exception
ex){
Console.WriteLine(ex.Message);
}
Instruções throw
Quando precisamos gerar as nossas
próprias exceções utilizamos a instrução throw, geralmente utilizamos a
instrução throw quando queremos fazer alguma validação, a sua sintaxe
está listada abaixo:
throw
new classeParaManipulaçãoExceção;
Exemplo:
int i =
0;
if (i==0)
throw new
System.DivideByZeroException();
Conclusão
O C# nós oferece um eficiente tratamento
de exceções,onde o desenvolvedor poderá utilizar as classes de manipulação de
exceções do próprio C# ou mesmo customizar a sua própria classe de exceção
apartir da classe ApplicationException.
Um grande abraço a todos.