Explicando try-catch com analogias de Harry Potter
- #C#
Em algumas circunstâncias pode ser complicado entender certas estruturas de controle, uma bem conhecida é o "try-catch", ela é usada para manipular exceções(erros) durante a execução de um bloco de códigos.
Para explicar melhor sobre, vou utilizar nesse artigo uma analogia com Harry Potter.
Imagine que você está em uma aula de Feitiços em Hogwarts, e a professora Minerva está ensinando um feitiço para transformar um sapo em um copo. Você, sendo um aluno bem no estilo Hermione que não quer errar, tenta lançar o feitiço corretamente, mas algo dá errado no meio do processo.
Aqui está como isso se relaciona com o try-catch em C#:
O Feitiço (Try): Quando você tenta lançar o feitiço para transformar o sapo em um copo, você está dentro do bloco try em C#. Este é o bloco onde você coloca o código que pode lançar uma exceção. É como a parte do código onde você tenta executar uma ação que pode falhar.
O Erro (Catch): Se algo der errado enquanto você está lançando o feitiço, isso seria como uma exceção sendo lançada em C#. Por exemplo, se você pronunciar uma palavra do feitiço errada, o feitiço falhará. No mundo de Harry Potter, isso seria semelhante a uma "exceção mágica" ocorrendo. O bloco catch em C# é como um feitiço que você lança para corrigir o erro. Você pode capturar a exceção (ou seja, pegar o erro) e lidar com ele de uma maneira específica. Por exemplo, você pode tentar lançar o feitiço novamente com mais cuidado ou lançar um feitiço alternativo para consertar o que deu errado.
Gryffindor vs. Slytherin: Imagine que o feitiço falhou e agora você tem que decidir o que fazer. Se você for um Gryffindor corajoso, pode tentar lançar o feitiço novamente com mais determinação. Isso seria como tentar resolver o problema dentro do bloco catch e continuar executando o código após o erro. Por outro lado, se você for um Slytherin astuto, pode decidir que lançar o feitiço novamente não é a melhor opção e pode optar por usar um feitiço diferente para alcançar o mesmo resultado. Isso seria como lançar uma exceção diferente ou retornar um valor padrão dentro do bloco catch.
Professor Dumbledore (Finally): No mundo de Harry Potter, o Professor Dumbledore sempre está lá para orientar os alunos e garantir que tudo termine bem(ainda mais se você for o da Gryffidor). Em C#, o bloco finally é como o Professor Dumbledore garantindo que, independentemente do que aconteça (ou seja, se ocorrer um erro ou não), certas ações sejam realizadas. Isso pode ser usado para liberar recursos ou fazer uma limpeza após o código no bloco try e catch.
Certo, agora vou te mostrar um exemplo em programação:
using System;
class Program
{
static void Main()
{
try
{
Console.WriteLine("Entrando no bloco try...");
// Simulando uma operação que pode lançar uma exceção
int resultado = 10 / 0; // Divisão por zero
}
catch (Exception ex)
{
Console.WriteLine("Erro capturado: " + ex.Message);
}
finally
{
Console.WriteLine("Bloco finally executado.");
}
}
}
Neste exemplo, tentei fazer uma divisão por zero dentro do bloco try, mais isso resultará em uma exceção sendo lançada. Dessa forma, o código dentro do bloco catch será executado para lidar com essa exceção. Em seguida, o bloco finally será executado, independentemente de uma exceção ter sido lançada ou não.
Pra fixar melhor vamos então fazer um exercício:
Exercício: Calculadora
Você foi designado para criar uma calculadora simples em C#. No entanto, você precisa garantir que a calculadora seja à prova de erros, lidando adequadamente com qualquer exceção que possa ocorrer durante as operações aritméticas básicas.
Requisitos:
- Crie um programa que permita ao usuário inserir dois números e escolher uma operação aritmética: adição, subtração, multiplicação ou divisão.
- Implemente as operações aritméticas usando um bloco try-catch para lidar com exceções que possam ocorrer, como divisão por zero ou conversão de entrada inválida.
- Se uma exceção ocorrer, imprima uma mensagem de erro apropriada e permita que o usuário tente novamente.
- Após cada operação bem-sucedida, pergunte ao usuário se ele deseja continuar calculando ou sair do programa.
Como ficaria o código:
using System;
class Program
{
static void Main()
{
Console.WriteLine("Bem-vindo à Calculadora!\n");
char continuar;
do
{
try
{
Console.Write("Digite o primeiro número: ");
double num1 = double.Parse(Console.ReadLine());
Console.Write("Digite o segundo número: ");
double num2 = double.Parse(Console.ReadLine());
Console.WriteLine("Escolha a operação:");
Console.WriteLine("1. Adição");
Console.WriteLine("2. Subtração");
Console.WriteLine("3. Multiplicação");
Console.WriteLine("4. Divisão");
Console.Write("Escolha uma opção: ");
int opcao = int.Parse(Console.ReadLine());
double resultado = 0;
switch (opcao)
{
case 1:
resultado = num1 + num2;
break;
case 2:
resultado = num1 - num2;
break;
case 3:
resultado = num1 * num2;
break;
case 4:
if (num2 == 0)
{
throw new DivideByZeroException("Erro: Tentativa de divisão por zero!");
}
resultado = num1 / num2;
break;
default:
Console.WriteLine("Opção inválida!");
continue;
}
Console.WriteLine("Resultado: " + resultado);
}
catch (FormatException)
{
Console.WriteLine("Erro: Entrada inválida! Por favor, insira um número válido.");
}
catch (DivideByZeroException ex)
{
Console.WriteLine(ex.Message);
}
catch (Exception ex)
{
Console.WriteLine("Erro inesperado: " + ex.Message);
}
finally
{
Console.Write("\nDeseja continuar calculando? (S/N): ");
continuar = char.ToUpper(Console.ReadKey().KeyChar);
Console.WriteLine("\n");
}
} while (continuar == 'S');
Console.WriteLine("Obrigado por usar a Calculadora!");
}
}
Neste código, utilizamos o bloco try-catch para lidar com possíveis exceções que podem ocorrer durante as operações aritméticas. Se uma exceção ocorrer, uma mensagem de erro apropriada será exibida. O bloco finally é usado para perguntar ao usuário se deseja continuar calculando após cada operação. O programa continua rodando até que o usuário decida parar.
Voltando para a nossa analogia com Harry Potter, o try-catch é como um feitiço de proteção em C#, permitindo que você antecipe e lide com erros durante a execução do seu código, garantindo que sua aplicação não falhe de forma inesperada e que você possa lidar com possíveis problemas de forma controlada, assim como um bruxo em Hogwarts se prepararia para qualquer eventualidade ao lançar feitiços complexos.
Referências:
https://learn.microsoft.com/pt-br/dotnet/csharp/language-reference/statements/exception-handling-statements - Acesso em 23 de Fevereiro de 2024.
