Criando e lançando exceções (Guia de Programação em C#)

Artigo
06/10/2015

Exceções são usadas para indicar que um erro ocorreu durante a execução do programa. Objetos de exceção que descrevem um erro são criados e, em seguida lançada com o lança palavra-chave. O tempo de execução, em seguida, pesquisa 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 dessa 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 instrução, para que as exceções devem ser lançadas desde o ponto em que 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 definida como o nome do argumento que causou a exceção seja lançada. No caso de um setter de propriedade, ParamName deve ser definida como value.

Membros de métodos public e protected devem lançar exceções, sempre que eles não é possível concluir suas funções pretendidas. A classe de exceção que é 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.

Procedimentos para evitar que 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 da 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 Exception, SystemException, NullReferenceException, ou IndexOutOfRangeException intencionalmente a partir de seu próprio código fonte.
Não crie exceções que podem ser geradas no modo de depuração, mas não o modo de versão. Para identificar erros de 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 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 um padrão, uma 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 forem adicionadas à classe derivada de exceção, ToString() deve ser substituído para retornar as informações adicionadas.

Especificação da linguagem C#

Para obter mais informações, consulte a Especificação da linguagem C#. A especificação da linguagem é a fonte definitiva para a sintaxe e o uso de C#.

Consulte também

Referência

Exceções e manipulação de exceções (Guia de Programação em C#)

Manipulação de exceções (Guia de Programação em C#)

Conceitos

Guia de Programação em C#

Hierarquia de exceções

Compartilhar via