Função em C# - Try...Catch

Criando uma função em C#

Uma função é um bloco de código que executa uma tarefa específica. Ela ajuda a organizar o programa dividindo-o em partes menores e mais gerenciáveis. Funções podem ser chamadas várias vezes de diferentes partes do programa, o que evita a repetição de código e torna o programa mais eficiente. Ao declarar uma função, precisamos fornecer algumas informações para que ela seja compreendida pelo interpretador. Essas informações incluem o Modificadores de acesso, retorno, nome e parâmetros. Com base nessas especificações, criamos uma função que pode ser utilizada em nosso programa, essas informações são essenciais para definir como a função será chamada e qual comportamento ela terá quando executada.

// Modificadores de acesso
// O retorno desta função deve ser do tipo int
// O nome da nossa função é `Dividir`
// `numerador` e `denominador` são os parâmetros obrigatórios que essa função deve receber para funcionar
// O bloco { ... } contém o código que a função executará
static int Dividir(int numerador, int denominador) { ... }

Tratamento de erro de uma função

Em C# eles são uma estrutura fundamental para lidar com exceções durante a execução de um bloco de código quando estamos escrevendo, é importante lidar com possíveis erros de uma maneira que não bagunce a saída do nosso programa no console. O bloco try...catch nos permite fazer isso de forma simples e compreensível. Ao envolver partes do nosso código que podem gerar erros no bloco try e capturar esses erros usando blocos catch , podemos tratá-los de forma organizada.

A estrutura do bloco try...catch é simples e pratica de ser colocada.

try
{
  // Aqui vai o bloco de código que você deseja executar
}
catch
{
  // Aqui você lida com a exceção gerada, pode ser de qualquer tipo
}

Explicação dos termos

O bloco try encapsula o código que pode gerar exceções. Ele tentará executar esse código normalmente, mas se ocorrer um erro durante a execução, o controle será transferido para o próximo bloco.
O bloco catch é onde as exceções são capturadas e tratadas. Aqui, podemos especificar o tipo de exceção que queremos capturar, permitindo-nos personalizar o tratamento com base no tipo de erro que ocorreu. Podemos inclusive capturar mais de um tipo de exceção em um único bloco Catch, possibilitando o tratamento de diferentes situações excepcionais dentro de uma única função.

catch
{
  Console.WriteLine("Mensagem de erro.")
}

Captura genérica
Nesse caso, o bloco catch captura qualquer tipo de exceção que ocorra dentro do bloco try. Isso é útil quando você deseja lidar com todas as exceções de maneira semelhante, sem se importar com o tipo específico da exceção.

catch (ClasseDeExceçãoEspecifica e)
{
  Console.WriteLine("O seguinte erro aconteceu: " + e.Message);
}

Captura especifica
Aqui, o bloco catch captura apenas exceções do tipo ClasseDeExeçãoEspecifica . Isso permite que você personalize o tratamento com base no tipo específico de exceção que ocorreu. A variável e contém informações sobre a exceção capturada, como a mensagem de erro, que podem ser usadas para fornecer informações úteis ao usuário ou para fins de depuração.
ClasseDeExeçãoEspecifica pode ser qualquer classe que capture exceções, assim como Exception ou DivideByZeroException ou até mesmo classes de exceção personalizadas que você definiu em seu código.

...try...catch
finally
{
  // Código que deve ser executado sempre, independentemente de ocorrer uma exceção ou não
  Console.WriteLine("Finalizando operação...");
}

O finally é uma parte opcional da estrutura try...catch em C#. Ele é usado para definir código que deve ser executado independentemente de ocorrer ou não uma exceção dentro do bloco try .

// Função demonstrativa onde iremos dividir dois números inteiros. Caso o usuário
// coloque alguma dessas condições `if`, ele irá gerar e capturar o erro com o `throw`,
// transmitindo o erro para algum bloco `catch` próximo.
static int Dividir(int numerador, int denominador)
{
  if (denominador == 0)
  {
    throw new DivideByZeroException("Divisor não pode ser zero.");
  }
if (numerador < 0 || denominador < 0)
{
    throw new ArgumentException("Numerador e denominador devem ser números positivos.");
  }
return numerador / denominador;
}

O throw é utilizado para propagar uma exceção capturada para um bloco Catch mais próximo, revertendo o fluxo de execução. Ele nos permite capturar o erro gerado e tratá-lo de maneira adequada.

Após a execução, o processo segue da seguinte maneira dentro do programa

// Bloco de execução da função anterior onde o bloco de execução `TRY` irá rodar normalmente,
// chamando a função `Dividir` criada anteriormente. Com base na demonstração, vemos que o denominador
// é igual a `0`, então teremos uma exceção, onde o `throw` criado anteriormente enviará
// para nós a `DivideByZeroException` com a mensagem que colocamos: `Divisor não pode ser zero.`
// Assim, isso cairá dentro do segundo bloco de `Catch`.
try
{
  int resultado = Dividir(10, 0);
Console.WriteLine("Resultado da divisão: " + resultado);
}
catch (DivideByZeroException ex)
{
  Console.WriteLine("Erro ao tentar dividir por zero: " + ex.Message);
}
catch (ArgumentException ex)
{
  Console.WriteLine("Erro ao tentar dividir: " + ex.Message);
}
catch (Exception ex)
{
  Console.WriteLine("Ocorreu uma exceção inesperada: " + ex.Message);
}
finally
{
Console.WriteLine("Finalizando operação...");
}

Conclusão

Em suma, o uso do bloco try...catch em C# é essencial para lidar com exceções de maneira controlada e garantir a estabilidade e robustez do nosso código. Ele nos permite executar blocos de código propensos a erros dentro de um ambiente seguro, onde exceções podem ser capturadas e tratadas de forma apropriada. Ao encapsular código que pode gerar exceções dentro do bloco try, podemos monitorar e responder a possíveis erros de forma organizada. Além disso, o uso de blocos catch nos permite personalizar o tratamento para diferentes tipos de exceções, fornecendo mensagens claras e informativas sobre o que deu errado. Em resumo, o bloco try...catch é uma ferramenta poderosa que nos ajuda a escrever código mais robusto, seguro e resiliente, garantindo uma experiência de usuário mais estável e confiável.

links

https://www.tutorialsteacher.com/csharp/csharp-exception-handling

https://www.csharptutorial.net/csharp-tutorial/csharp-try-catch/