Criação e lançamento de exceções (guia de programação de C#)

Artigo
08/04/2011

Exceções são usadas para indicar que um erro ocorreu durante a execução do programa. São criados objetos de exceção que descrevem um erro e, em seguida, acionada com o Lançar palavra-chave. O tempo de execução procura o manipulador de exceção mais compatível.

Os programadores devem lançar exceções quando uma ou mais das condições a seguir são verdadeiras:

O método não pode concluir sua funcionalidade definida.

Por exemplo, se um parâmetro para um método tem um valor inválido:

static void CopyObject(SampleClass original)
{
    if (original == null)
    {
        throw new System.ArgumentException("Parameter cannot be null", "original");
    }

}

É feita uma chamada inadequada a um objeto com base no estado do objeto.

Um exemplo é tentar gravar em um arquivo somente leitura de leitura. Em casos onde o estado de um objeto não permite uma operação, lançar uma instância de InvalidOperationException ou um objeto com base em uma derivação desta classe. Este é um exemplo de um método que lança um InvalidOperationException objeto:
```
class ProgramLog
{
    System.IO.FileStream logFile = null;
    void OpenLog(System.IO.FileInfo fileName, System.IO.FileMode mode) {}

    void WriteLog()
    {
        if (!this.logFile.CanWrite)
        {
            throw new System.InvalidOperationException("Logfile cannot be read-only");
        }
        // Else write data to the log and return.
    }
}
```

Quando um argumento para um método causa uma exceção.

Nesse caso, a exceção original deve ser detectada e um ArgumentException instância deve ser criada. A exceção original deve ser passada para o construtor da ArgumentException como o InnerException parâmetro:

static int GetValueFromArray(int[] array, int index)
{
    try
    {
        return array[index];
    }
    catch (System.IndexOutOfRangeException ex)
    {
        System.ArgumentException argEx = new System.ArgumentException("Index is out of range", "index", ex);
        throw argEx;
    }
}

Exceções contém uma propriedade chamada StackTrace. Esta string contém o nome dos métodos na pilha de chamadas atual, juntamente com o número de linha e o nome do arquivo onde a exceção foi lançada para cada método. A StackTrace objeto é criado automaticamente pelo common language runtime (CLR) do ponto da throw de instrução, para que as exceções devem ser lançadas do ponto onde o rastreamento de pilha deve começar.

Todas as exceções contém uma propriedade chamada Message. Essa seqüência de caracteres deve ser definida para explicar o motivo da exceção. Observe que as informações que são sensíveis à segurança não devem ser colocadas no texto da mensagem. Além das Message, ArgumentException contém uma propriedade chamada ParamName que deve ser definido como o nome do argumento que causou a exceção ser acionada. No caso de um setter de propriedade, ParamName deve ser definido como value.

Os membros de métodos públicos e protegidos devem lançar exceções, sempre que ele não poderá concluir suas funções pretendidas. A classe de exceção é lançada deve ser a exceção mais específica disponível que atenda às condições de erro. Essas exceções devem ser documentadas como parte da funcionalidade de classe e classes derivadas ou atualizações para a classe original devem reter o mesmo comportamento para compatibilidade com versões anteriores. Para obter mais informações, consulte Diretrizes de design para exceções.

Procedimentos para evitar ao gerar exceções

A lista a seguir identifica as práticas recomendadas para evitar ao gerar exceções:

Exceções não devem ser usadas para alterar o fluxo de um programa como parte de execução comum. Exceções só devem ser usadas para relatar e manipular condições de erro.
Exceções não devem ser retornadas como um valor de retorno ou parâmetro em vez de ser lançada.
Não jogue a System.Exception, System.SystemException, System.NullReferenceException, ou System.IndexOutOfRangeException intencionalmente do seu próprio código de origem.
Não crie exceções que podem ser lançadas no modo de depuração, mas não o modo de versão. Para identificar erros em tempo de execução durante a fase de desenvolvimento, use depurar Assert.

Definir Classes de exceção

Programas podem lançar uma classe de exceção predefinidos na System o namespace (exceto onde observado anteriormente), ou criar suas próprias classes de exceção, derivando de Exception. As classes derivadas devem definir pelo menos quatro construtores: construtor padrão de um, que define a propriedade de mensagem e uma que define ambas as Message e InnerException Propriedades. O quarto construtor é usado para serializar a exceção. Novas classes de exceção devem ser serializáveis. Por exemplo:

[Serializable()]
public class InvalidDepartmentException : System.Exception
{
    public InvalidDepartmentException() : base() { }
    public InvalidDepartmentException(string message) : base(message) { }
    public InvalidDepartmentException(string message, System.Exception inner) : base(message, inner) { }

    // A constructor is needed for serialization when an
    // exception propagates from a remoting server to the client. 
    protected InvalidDepartmentException(System.Runtime.Serialization.SerializationInfo info,
        System.Runtime.Serialization.StreamingContext context) { }
}

Novas propriedades só devem ser adicionadas à classe de exceção quando os dados que elas fornecem são úteis para resolver a exceção. Se novas propriedades são adicionadas à classe derivada de exceção, ToString() deve ser substituído para retornar informações adicionadas.