Asserções em código gerenciado
Uma asserção, ou instrução Assert, testa uma condição, que você especifica como um argumento para a instrução Assert. Se a condição for avaliada para true, nenhuma ação ocorrerá. Se a condição for avaliada como false, haverá falha de asserção. Se você estiver executando com uma compilação de depuração, o programa entrará no modo de interrupção.
Neste tópico
Asserções in no namespace System.Diagnostics
O método Debug.Assert
Efeitos colaterais de Debug.Assert
Requisitos de rastreamento e depuração
Declarar argumentos
Personalizar o comportamento de asserção
Configurar asserções nos arquivos de configuração
Asserções in no namespace System.Diagnostics
No Visual Basic e Visual C #, você pode usar o método Assert de Debug ou Trace, que estão no namespace System.Diagnostics. Os métodos da classe Debug não estão incluídos em uma versão de lançamento do programa, portanto, não aumentam o tamanho nem reduzem a velocidade do código da versão.
C++ não oferece suporte aos métodos da classe Debug. Você pode obter o mesmo efeito usando a classe Trace com compilação condicional, por exemplo, #ifdef DEBUG… #endif.
Neste tópico
O método Debug.Assert
Use o método Debug.Assert livremente para testar condições que devem resultar em valores verdadeiros se seu código estiver correto. Por exemplo, suponha que você tenha escrito uma função de divisão de inteiros. Pelas regras da matemática, o divisor nunca pode ser zero. Você pode testar isso usando uma asserção:
Function IntegerDivide(ByVal dividend As Integer, ByVal divisor As Integer) As Integer
Debug.Assert(divisor <> 0)
Return CInt(dividend / divisor)
End Function
int IntegerDivide ( int dividend , int divisor )
{ Debug.Assert ( divisor != 0 );
return ( dividend / divisor ); }
Quando você executar esse código no depurador, a instrução de asserção será avaliada, mas, na versão lançada, a comparação não é feita, para não haver sobrecarga adicional.
Aqui está outro exemplo. Você tem uma classe que implementa uma conta corrente, como segue:
Dim amount, balance As Double
balance = savingsAccount.balance
Debug.Assert(amount <= balance)
SavingsAccount.Withdraw(amount)
float balance = savingsAccount.Balance;
Debug.Assert ( amount <= balance );
savingsAccount.Withdraw ( amount );
Antes de retirar o dinheiro da conta, você quer garantir que o saldo seja suficiente para cobrir o valor que quer sacar. Você pode escrever uma asserção para verificar o saldo:
Dim amount, balance As Double
balance = savingsAccount.balance
Trace.Assert(amount <= balance)
SavingsAccount.Withdraw(amount)
float balance = savingsAccount.Balance;
Trace.Assert ( amount <= balance );
savingsAccount.Withdraw ( amount );
Observe que as chamadas para o método Debug.Assert desaparecem quando você cria uma versão de lançamento do código. Isso significa que a chamada que verifica o saldo desaparece na versão de lançamento. Para resolver esse problema, você deverá substituir Debug.Assert por Trace.Assert, que não desaparece na versão de lançamento:
As chamadas para Trace.Assert adicionam sobrecarga para a versão de lançamento, ao contrário das chamadas para Debug.Assert.
Neste tópico
Efeitos colaterais de Debug.Assert
Quando você usar Debug.Assert, verifique se algum código Assert interno alterará os resultados do programa se Assert for removido. Caso contrário, você poderá acidentalmente introduzir um bug que aparece somente na versão de lançamento do programa. Tenha cuidado especial sobre asserções que contêm chamadas de função ou procedimento, como o exemplo a seguir:
' unsafe code
Debug.Assert (meas(i) <> 0 )
// unsafe code
Debug.Assert (meas(i) != 0 );
Este uso de Debug.Assert talvez pareça seguro à primeira vista, mas suponhamos que a função meas atualize um contador sempre que for chamada. Quando você compilou a versão de lançamento, essa chamada para meas é eliminada, de modo que 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 bug que aparece somente na versão de lançamento. Para evitar esses problemas, não coloque chamadas de função em uma instrução Debug.Assert. Use uma variável temporária em vez disso:
temp = meas( i )
Debug.Assert (temp <> 0)
temp = meas( i );
Debug.Assert ( temp != 0 );
Mesmo quando você usa Trace.Assert, talvez ainda queira evitar colocar chamadas de função em uma instrução Assert. Essas chamadas devem ser seguras, porque as instruções Trace.Assert não são eliminadas em uma compilação de lançamento. No entanto, se você evitar construções por uma questão de hábito, será menos provável cometer um erro quando usar Debug.Assert.
Neste tópico
Requisitos de rastreamento e depuração
Se você criar seu projeto usando os assistentes do Visual Studio, o símbolo TRACE será definido por padrão nas configurações de lançamento e depuração. O símbolo DEBUG é definido por padrão apenas na compilação de depuração.
Caso contrário, para que os métodos Trace funcionem, o programa deverá ter um dos seguintes na parte superior do arquivo de origem:
#Const TRACE = True no Visual Basic
#define TRACE no Visual C# e C++
Ou o programa deverá ser compilado com a opção TRACE:
/d:TRACE=True no Visual Basic
/d:TRACE no Visual C# e C++
Se você precisar usar os métodos de depuração em uma compilação de lançamento do C# ou Visual Basic, deverá definir o símbolo DEBUG na configuração de lançamento.
C++ não oferece suporte aos métodos da classe Debug. Você pode obter o mesmo efeito usando a classe Trace com compilação condicional, por exemplo, #ifdef DEBUG… #endif. Você pode definir esses símbolos na caixa de diálogo <Projeto> Páginas de Propriedades. Para obter mais informações, consulte Alterando as configurações de projeto para uma configuração de depuração do Visual Basic ou Alterando as configurações de projeto para uma configuração de depuração do C ou C++.
Declarar argumentos
Trace.Assert e Debug.Assert utilizam até três argumentos. O primeiro argumento, que é obrigatório, é a condição que você deseja verificar. Se você chamar Trace.Assert(Boolean) ou Debug.Assert(Boolean) com apenas um argumento, o método Assert verifica a condição e, se o resultado for false, gera o conteúdo da pilha de chamadas para a janela Saída. O exemplo a seguir mostra Trace.Assert(Boolean) e Debug.Assert(Boolean):
Debug.Assert(stacksize > 0)
Trace.Assert(stacksize > 0)
Debug.Assert ( stacksize > 0 );
Trace.Assert ( stacksize > 0 );
O segundo e o terceiro argumentos, se houver, devem ser cadeias de caracteres. Se você chamar Trace.Assert ou Debug.Assert com dois ou três argumentos, o primeiro será uma condição. O método verifica a condição e, se o resultado for false, gera a segunda e a terceira cadeias de caracteres. O exemplo a seguir mostra Debug.Assert(Boolean, String) e Trace.Assert(Boolean, String) usados com dois argumentos:
Debug.Assert(stacksize > 0, "Out of stack space")
Trace.Assert(stacksize > 0, "Out of stack space")
Debug.Assert ( stacksize > 0, "Out of stack space" );
Trace.Assert ( stacksize > 0, "Out of stack space" );
O exemplo a seguir mostra Assert e Assert:
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" )
Debug.Assert ( stacksize > 100, "Out of stack space" , "Failed in inctemp" );
Trace.Assert ( stacksize > 0, "Out of stack space", "Failed in inctemp" );
Neste tópico
Personalizar o comportamento de asserção
Se você executar o seu aplicativo no modo de interface do usuário, o método Assert exibirá a caixa de diálogo Falha de Asserção quando a condição falhar. As ações que ocorrem quando uma asserção falha são controladas pela propriedade Listeners ou Listeners.
Você pode personalizar o comportamento de saída adicionando um objeto TraceListener à coleção de Listeners, removendo TraceListener da coleção de Listeners ou substituindo o método TraceListener.Fail do TraceListener existente para obrigá-lo a se comportar de maneira diferente.
Por exemplo, você pode substituir o método TraceListener.Fail para gravar em um log de eventos em vez de exibir a caixa de diálogo Falha de Asserção.
Para personalizar a saída dessa forma, o programa deverá conter um ouvinte e você deverá herdar de TraceListener e substituir o método TraceListener.Fail.
Para obter mais informações, consulte Ouvintes de rastreamento.
Neste tópico
Configurar asserções nos arquivos de configuração
Você pode definir asserções em seu arquivo de configuração do programa assim como em seu código. Para obter mais informações, consulte Trace.Assert ou Debug.Assert.
Consulte também
Tarefas
Como compilar condicionalmente com Trace e Debug
Referência
Conceitos
Outros recursos
Rastreamento e instrumentação de aplicativos
Preparação de depuração: tipos de projeto C#, F# e Visual Basic