Entendendo o tratamento de exceções

Bem-vindo à próxima lição! Nesta lição, você aprenderá sobre o tratamento de exceções em C#, sua importância e como tratar erros de forma eficaz em seus aplicativos. Vamos começar!

O que é tratamento de exceções?

O tratamento de exceções é um mecanismo para responder a erros de execução de maneira controlada. Ele garante que seu programa possa se recuperar de condições inesperadas de forma adequada.

Ponto principal: Use o tratamento de exceções para impedir que seu aplicativo seja encerrado inesperadamente e fornecer informações úteis aos usuários.

O bloco Try-Catch

O bloco try-catch é usado para tratar exceções. O código que pode gerar uma exceção é colocado dentro do bloco try, e o bloco catch trata a exceção. Exemplo:

Ponto principal: Use tipos específicos de exceção no bloco catch para tratar erros diferentes.

using System;

class Program {
    static void Main() {
        try {
            int result = 10 / 0; // This will throw a DivideByZeroException
        } catch (DivideByZeroException ex) {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

O bloco Finally

O bloco finally é usado para executar códigos que devem ser executados independentemente de ocorrer ou não uma exceção. Exemplo:

Dica: Use o bloco finally para operações de limpeza, como fechar arquivos ou conexões com bancos de dados.

using System;

class Program {
    static void Main() {
        try {
            int[] numbers = { 1, 2, 3 };
            Console.WriteLine(numbers[5]); // This will throw an IndexOutOfRangeException
        } catch (IndexOutOfRangeException ex) {
            Console.WriteLine("Error: " + ex.Message);
        } finally {
            Console.WriteLine("This will always execute.");
        }
    }
}

Lançando exceções

Você pode usar a palavra-chave throw para gerar exceções manualmente. Exemplo:

Ponto principal: Lance exceções para impor regras ou tratar condições inválidas no seu aplicativo.

using System;

class Program {
    static void Main() {
        try {
            ValidateAge(15);
        } catch (Exception ex) {
            Console.WriteLine("Error: " + ex.Message);
        }
    }

    static void ValidateAge(int age) {
        if (age < 18) {
            throw new ArgumentException("Age must be 18 or older.");
        }
    }
}

Exceções personalizadas

Você pode definir classes de exceção personalizadas para tratar erros específicos do aplicativo. Exemplo:

Dica: Use exceções personalizadas para fornecer mensagens de erro úteis e específicas da lógica do seu aplicativo.

using System;

class CustomException : Exception {
    public CustomException(string message) : base(message) {}
}

class Program {
    static void Main() {
        try {
            throw new CustomException("This is a custom exception.");
        } catch (CustomException ex) {
            Console.WriteLine("Caught custom exception: " + ex.Message);
        }
    }
}

Desafio prático

Crie um programa que receba como entrada do usuário um número e lance uma exceção se o número for negativo. Use um bloco try-catch para tratar a exceção. Exemplo:

using System;

class Program {
    static void Main() {
        try {
            Console.WriteLine("Enter a number:");
            int number = int.Parse(Console.ReadLine());
            if (number < 0) {
                throw new ArgumentException("Number cannot be negative.");
            }
            Console.WriteLine("You entered: " + number);
        } catch (Exception ex) {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

Práticas recomendadas para o tratamento de exceções

Veja algumas práticas recomendadas:

• Capture apenas exceções específicas para evitar ocultar outros erros.
• Use o bloco finally para a limpeza de recursos.
• Lance exceções para situações excepcionais, não para controlar o fluxo.
• Registre as exceções para acompanhar problemas em ambientes de produção.

Dica: Um tratamento adequado de exceções torna seu aplicativo mais robusto e fácil de usar.

Muito bem!

Parabéns! Você aprendeu a tratar exceções de forma eficaz para criar aplicativos resistentes a erros. Na próxima lição, exploraremos como trabalhar com bancos de dados para gerenciar e consultar dados. Continue programando!