Share via

Asserção no código gerenciado

  • Artigo

Este tópico se aplica a:

Edição

Visual Basic

C#

C++

Desenvolvedores Web

Express

Padrão

PRO e equipe

Legenda de tabela:

Aplica-se

Não é aplicada

Comando ou comandos oculta por padrão.

Uma asserção, ou Assert demonstrativo, testa uma condição, que você especificar sistema autônomo um argumento para o Assert demonstrativo. Se a condição for avaliada como True, nenhuma ação ocorre.Se a condição for avaliada como False, a declaração falhará.Se você estiver executando com uma compilação para depuração, seu programa insere modo de interrupção.

No Visual Basic e Visual translation from VPE for Csharp, você pode usar o Assert método a partir de um Debug ou Trace, que estão na System.Diagnostics espaço para nome. Debug métodos de classe não são incluídos em uma versão de lançamento do seu programa, para que não aumentam o dimensionar ou reduzam a velocidade do seu código de entrega.

C++ não dá suporte a Debug métodos da classe. Você pode obter o mesmo efeito usando o Trace classe com compilação condicional, tais sistema autônomo #ifdef DEBUG... #endif.

O método Debug.Assert

Use o Debug.Assert método livremente para testar condições que devem permanecer true se o código está correto. Por exemplo, suponha que você tenha escrito uma função de divisão de inteiros.Pelas regras de matemática, o divisor nunca pode ser zero.Você pode testar isso usando uma declaração:

[Visual Basic]

Function IntegerDivide(ByVal dividend As Integer, ByVal divisor As Integer) As Integer
    Debug.Assert(divisor <> 0)
    Return CInt(dividend / divisor)
End Function

[C#]

int IntegerDivide ( int dividend , int divisor )
    { Debug.Assert ( divisor != 0 );
        return ( dividend / divisor ); }

Quando você executar este código no depurador, a instrução de asserção é avaliada, mas na versão de lançamento, a comparação não é feita, portanto, não existirá nenhuma sobrecarga adicional.

Veja outro exemplo.Você tem uma classe que implementa uma conta checking, da seguinte forma:

[Visual Basic]

Dim amount, balance As Double
balance = savingsAccount.balance
Debug.Assert(amount <= balance)
SavingsAccount.Withdraw(amount)

[C#]

float balance = savingsAccount.Balance;
Debug.Assert ( amount <= balance );
savingsAccount.Withdraw ( amount );

Antes que retirar dinheiro da conta, você deseja verificar se o saldo da conta é suficiente para cobrir a quantidade que você está preparando para saque.Você pode escrever uma asserção para verificar o saldo:

[Visual Basic]

Dim amount, balance As Double
balance = savingsAccount.balance
Trace.Assert(amount <= balance)
SavingsAccount.Withdraw(amount)

[C#]

float balance = savingsAccount.Balance;
Trace.Assert ( amount <= balance );
savingsAccount.Withdraw ( amount );

Observe que chamadas para o Debug.Assert método desaparecem quando você cria uma versão de lançamento do seu código. Isso significa que a chamada que verifica o saldo desaparece na versão de lançamento.Para resolver esse problema, você deve substituir Debug.Assert com Trace.Assert, que não desaparece na versão de lançamento:

Chamadas para Trace.Assert adicionam sobrecarga a sua versão de lançamento, diferentemente de chamadas para Debug.Assert.

Efeitos colaterais de Debug.Assert

Quando você usa Debug.Assert, certifique-se de que qualquer código dentro de Assert não altera os resultados do programa se Assert é removido. Caso contrário, você pode introduzir um erro que aparece somente na versão de lançamento do seu programa acidentalmente.Tome cuidado principalmente com asserções que contêm chamadas de função ou procedimento, como o exemplo a seguir:

[Visual Basic]

' unsafe code
Debug.Assert (meas(i) <> 0 )

[C#]

// unsafe code
Debug.Assert (meas(i) != 0 );

Este uso de Debug.Assert pode parecer seguro a princípio, mas suponha que a meas da função atualiza um contador sempre que ela é chamada. Quando você cria a versão de lançamento, esta chamada para meas é eliminada, para o contador não ser atualizado.Este é um exemplo de uma função com um efeito colateral.Eliminar uma chamada para uma função que tem efeitos colaterais pode resultar em um erro que aparece apenas na versão de lançamento.Para evitar esses problemas, não posicione chamadas de função em um Debug.Assert demonstrativo. Use uma variável temporária:

[Visual Basic]

temp = meas( i )
Debug.Assert (temp <> 0)

[C#]

temp = meas( i );
Debug.Assert ( temp != 0 );

Mesmo quando você usa Trace.Assert, ainda convém evitar fazer chamadas de função dentro de um Assert demonstrativo. Essas chamadas deverão ser seguras, pois Trace.Assert instruções não são eliminados em uma criação para versão. No entanto, se você evitar tais construções sistema autônomo uma questão de hábito, você provavelmente menos cometa um erro ao usar Debug.Assert.

Requisitos de Depuração e Rastreamento

Se você criar seu projeto usando o Visual Studio assistentes, o símbolo TRACE é definido por padrão em configurações de liberação e depurar. O símbolo Debug é definido por padrão somente na compilação de depuração.

Caso contrário, para Trace métodos para trabalhar, o programa deve ter uma das seguintes opções na parte superior do arquivo de fonte:

  • #Const TRACE = True no Visual Basic

  • #define TRACE no Visual translation from VPE for Csharp e C++

Ou o programa deve ser criado com a opção Trace:

  • /d:TRACE=True no Visual Basic

  • /d:TRACE no Visual translation from VPE for Csharp e C++

Se você precisa usar os métodos de depuração em uma criação de versão C# ou Visual Basic, você deverá definir o símbolo Debug em sua configuração de lançamento.

C++ não dá suporte a Debug métodos da classe. Você pode obter o mesmo efeito usando o Trace classe com compilação condicional, tais sistema autônomo #ifdef DEBUG... #endif.Você pode definir esses símbolos no Propriedade <projeto>páginas caixa de diálogo.Para obter mais informações, consulte Alterar configurações do projeto para um Visual Basic depurar configuração or Alterar configurações do projeto para um C ou C++ depurar configuração.

Declarar argumentos

Trace.Assert e Debug.Assert levam até três argumentos. O primeiro argumento, que é obrigatório, é a condição que deseja verificar.If you telefonar Trace.Assert(Boolean) ou Debug.Assert(Boolean) com apenas um argumento, o Assert método verifica a condição e, se o resultado é false, mostra o Sumário do telefonar da pilha para o Saída janela.O exemplo a seguir mostra Trace.Assert(Boolean) e Debug.Assert(Boolean):

[Visual Basic]

Debug.Assert(stacksize > 0)
Trace.Assert(stacksize > 0)

[C#]

Debug.Assert ( stacksize > 0 );
Trace.Assert ( stacksize > 0 );

Os argumentos segundo e terceiro, se houver, devem ser sequências.Se você chamar Trace.Assert ou Debug.Assert com dois ou três argumentos, o primeiro argumento é uma condição. O método verifica a condição e, se o resultado for FALSO, mostra a segunda e terceira sequências.O exemplo a seguir mostra Debug.Assert(Boolean, String) e Trace.Assert(Boolean, String) usado com dois argumentos:

[Visual Basic]

Debug.Assert(stacksize > 0, "Out of stack space")
Trace.Assert(stacksize > 0, "Out of stack space")

[C#]

Debug.Assert ( stacksize > 0, "Out of stack space" );
Trace.Assert ( stacksize > 0, "Out of stack space" );

O exemplo a seguir mostra Assert e Assert:

[Visual Basic]

Debug.Assert(stacksize > 0, "Out of stack space. Bytes left:" , Format(size, "G"))
Trace.Assert(stacksize > 0, "Out of stack space. Bytes left:" , Format(size, "G"))
Trace.Assert(stacksize > 0, "Out of stack space. Bytes left:", "inctemp failed on third call" )

[C#]

Debug.Assert ( stacksize > 100, "Out of stack space" , "Failed in inctemp" );
Trace.Assert ( stacksize > 0, "Out of stack space", "Failed in inctemp" );

Personalizando comportamento de declaração

Se você executar o aplicativo no modo de interface do usuário, a Assert método exibe a Falha de declaração caixa de diálogo quando a condição falhar.As ações que ocorrem quando uma declaração falha são controladas pelo Listeners ou Listeners propriedade.

Você pode personalizar o comportamento de saída adicionando um TraceListener objeto para o Listeners coleção, removendo um TraceListener do Listeners coleção, ou substituindo o TraceListener.Fail método de um existente TraceListener para torná-lo se comportam de maneira diferente.

Por exemplo, você pode substituir o TraceListener.Fail método para gravar um log de eventos em vez de exibir o Falha de declaração caixa de diálogo.

Para personalizar a saída dessa forma, seu programa deve conter uma escuta e você deve herdar de TraceListener e substituir seu TraceListener.Fail método.

Para obter mais informações, consulte Ouvintes de Rastrear.

Definindo asserções em arquivos de configuração

Você pode definir itens em seu arquivo de configuração de programa, bem como em seu código.Para obter mais informações, consulte Trace.Assert ou Debug.Assert.

Consulte também

Tarefas

Como: Compilar condicionalmente com Rastrear e Depurar

Conceitos

Segurança do Depurador

Referência

Debug.Assert

Trace.Assert

Outros recursos

Rastreamento e intrumentando aplicações

Preparação para depuração: Translation from VPE for Csharp e tipos de projeto do Visual Basic

Depurando código gerenciado