Asserção no código gerenciado

Artigo
08/08/2011

This topic applies to:

Edition	Visual Basic	C#	C++	Web Developer
Express
Pro, Premium e Ultimate

Uma asserção, ou Assert de instrução, testa uma condição, você pode especificar como um argumento para o Assert instrução. If the condition evaluates to true, no action occurs. If the condition evaluates to false, the assertion fails. If you are running with a debug build, your program enters break mode.

No Visual Basic e C# Visual, você pode usar o Assert método a partir de um Debug ou Trace, que o System.Diagnostics namespace. Debugmétodos de classe não são incluídos em uma versão de lançamento do seu programa, portanto, não aumente o tamanho ou reduzam a velocidade do seu código.

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

The Debug.Assert Method

Use o Debug.Assert método livremente para testar condições que devem permanecer true se o código está correto. For example, suppose you have written an integer divide function. By the rules of mathematics, the divisor can never be zero. You might test this using an assertion:

[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 ); }

When you run this code under the debugger, the assertion statement is evaluated, but in the Release version, the comparison is not made, so there is no additional overhead.

Here is another example. You have a class that implements a checking account, as follows:

[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 );

Before you withdraw money from the account, you want to make sure that the account balance is sufficient to cover the amount you are preparing to withdraw. You might write an assertion to check the balance:

[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 as chamadas para o Debug.Assert método desaparecem quando você cria uma versão de lançamento do seu código. That means that the call that checks the balance disappears in the Release version. 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 Adicionar sobrecarga a sua versão de lançamento, diferentemente de chamadas para Debug.Assert.

Side Effects of 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. Otherwise, you might accidentally introduce a bug that only shows up in the Release version of your program. Be especially careful about asserts that contain function or procedure calls, such as the following example:

[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 é chamado. When you build the Release version, this call to meas is eliminated, so the counter does not get updated. This is an example of a function with a side effect. Eliminating a call to a function that has side effects could result in a bug that only appears in the Release version. Para evitar esses problemas, não posicione chamadas de função em um Debug.Assert instrução. Use a temporary variable instead:

[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 instrução. Essas chamadas deverão ser seguras, pois Trace.Assert instruções não são eliminados em uma compilação de lançamento. No entanto, se você evitar tais construções como uma questão de hábito, é menos probabilidade de cometer um erro quando você usa Debug.Assert.

Trace and Debug Requirements

Se você criar seu projeto usando o Visual Studio assistentes, o símbolo TRACE é definido por padrão nas configurações de lançamento e depuração. The DEBUG symbol is defined by default only in the Debug build.

Caso contrário, para Trace métodos para trabalhar, o programa deve ter um dos seguintes na parte superior do arquivo de origem:

#Const TRACE = Trueem Visual Basic
#define TRACEno Visual C# e C++

Or your program must be built with the TRACE option:

/d:TRACE=Trueem Visual Basic
/d:TRACEno Visual C# e C++

If you need to use the Debug methods in a C# or Visual Basic Release build, you must define the DEBUG symbol in your Release configuration.

C++ não dá suporte a Debug métodos de classe. Você pode obter o mesmo efeito usando o Trace de classe com compilação condicional, tais como #ifdef DEBUG... #endif. Você pode definir esses símbolos na <Project> Páginas de propriedade caixa de diálogo. Para obter mais informações, consulte Alterando configurações de projeto para depurar a configuração no Visual Basic ou Alterando configurações de projeto for a c or C++ Debug Configuration.

Assert Arguments

Trace.Asserte Debug.Assert levar até três argumentos. The first argument, which is mandatory, is the condition you want to check. Se você chamar Trace.Assert(Boolean) ou Debug.Assert(Boolean) com apenas um argumento, o Assert método verifica a condição e, se o resultado for falso, mostra o conteúdo da pilha de chamadas para o saída janela. A 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 );

The second and third arguments, if present, must be strings. Se você chamar Trace.Assert ou Debug.Assert com dois ou três argumentos, o primeiro argumento é uma condição. The method checks the condition and, if the result is false, outputs the second string and third strings. A 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" );

A 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" );

Customizing Assert Behavior

Se você executar o aplicativo no modo de interface do usuário, o Assert método exibe o Assertion Failed 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 o objeto para o Listeners coleção, removendo um TraceListener da Listeners coleção, ou substituindo o TraceListener.Fail método de uma existente TraceListener para torná-lo a se comportar de maneira diferente.

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

Para personalizar a saída dessa forma, o 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 rastreamento..

Setting Assertions in Configuration Files

You can set assertions in your program configuration file as well as in your code. For more information, see Trace.Assert or Debug.Assert.

Consulte também

Compartilhar via

Asserção no código gerenciado

The Debug.Assert Method

Side Effects of Debug.Assert

Trace and Debug Requirements

Assert Arguments

Customizing Assert Behavior

Setting Assertions in Configuration Files

Consulte também

Tarefas

Referência

Conceitos

Outros recursos

Recursos adicionais