O que são exceções na linguagem de programação C#?

As exceções em C# são situações anómalas ou erros que ocorrem durante a execução do programa e interrompem o seu fluxo normal.

Permitem separar o código de tratamento de erros do código principal de lógica da aplicação e proporcionam uma abordagem mais estruturada para gerir erros.

Principais aspetos das exceções em C#:

1. Tipos de exceções: C# possui uma hierarquia de classes de exceções padrão que herdam da classe base System.Exception. Por exemplo, System.NullReferenceException, System.DivideByZeroException, System.IO.FileNotFoundException. Também é possível criar classes de exceções personalizadas.
2. Geração de exceções (throw): A exceção é gerada usando a palavra-chave throw.
3. Captura de exceções (try-catch): O bloco try contém o código que pode gerar uma exceção. O bloco catch captura um tipo específico de exceção e executa o código para a tratar.
4. Bloco finally: O bloco finally é sempre executado, independentemente de uma exceção ter sido gerada ou não. É frequentemente usado para libertar recursos.
5. Operador using: Forma mais conveniente de gerir recursos, que garante a chamada do método Dispose. É semelhante à construção try-finally para objetos que implementam a interface IDisposable.
6. Filtros de exceções: Permitem adicionar uma condição ao bloco catch para uma gestão mais específica de exceções.

Exemplo de uso:

public class Example
{
    public void ProcessData(int denominator)
    {
        try
        {
            int result = 10 / denominator; // Pode gerar DivideByZeroException
            Console.WriteLine($"Resultado: {result}");
        }
        catch (DivideByZeroException ex) // Capturamos uma exceção específica
        {
            Console.WriteLine("Erro: Não é possível dividir por zero.");
            // Registo da exceção, se necessário
            // Console.WriteLine($"Detalhes da exceção: {ex.Message}");
        }
        catch (Exception ex) // Capturamos qualquer outra exceção
        {
            Console.WriteLine($"Ocorreu um erro inesperado: {ex.Message}");
        }
        finally // Este bloco será sempre executado
        {
            Console.WriteLine("Processamento terminado.");
        }
    }

    public void UsingExample()
    {
        // Exemplo de uso de using para chamar automaticamente Dispose
        using (StreamReader reader = new StreamReader("file.txt"))
        {
            string line = reader.ReadLine();
            Console.WriteLine(line);
        } // Aqui, reader.Dispose() é chamado automaticamente, mesmo que ocorra uma exceção
    }

    public void ThrowExample(int value)
    {
        if (value < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(value), "O valor deve ser não negativo."); // Geração de uma exceção própria
        }
        // ... lógica adicional
    }
}

O uso de exceções ajuda a criar aplicações mais robustas, legíveis e fáceis de manter, separando o tratamento de erros da lógica principal.