Aserciones en el código administrado

Este tema se aplica a:

Edición	Visual Basic	C#	C++	Web Developer
Express
Pro, Premium y Ultimate

Una aserción, o instrucción Assert, prueba una condición especificada como argumento en la misma. Si la condición se evalúa como true, no se produce ninguna acción. Si la condición se evalúa como false, se produce un error en la aserción. Si se ejecuta con una versión de depuración, el programa entra en modo de interrupción.

En Visual Basic y Visual C#, puede utilizar el método Assert de Debug o Trace, que están en el espacio de nombres System.Diagnostics. Los métodos de la clase Debug no están incluidos en una versión de lanzamiento de su programa, de modo que no aumentan el tamaño ni reducen la velocidad de su código de versión.

C++ no admite los métodos de clase Debug. Se puede conseguir el mismo efecto mediante la clase Trace con compilación condicional, por ejemplo #ifdef DEBUG. #endif.

Debug.Assert (Método)

Utilice el método Debug.Assert libremente para probar las condiciones que deberían ser ciertas (valor true) si el código es correcto. Por ejemplo, suponga que ha escrito una función de división de enteros. Según las reglas matemáticas, el divisor nunca puede ser cero. Puede probar esto mediante una aserción:

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

Cuando se ejecuta este código en el depurador, se evalúa la instrucción de aserción, pero en la versión de lanzamiento no se realiza la comparación, de modo que no se produce sobrecarga adicional.

A continuación se muestra otro ejemplo en el que se utiliza una clase que implementa una cuenta corriente, de la siguiente manera:

[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 de retirar dinero de la cuenta, desea asegurarse de que el saldo es suficiente para la cantidad que se dispone a retirar. Puede escribir una aserción para comprobar el 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 );

Tenga en cuenta que las llamadas al método Debug.Assert desaparecen cuando se crea una versión de lanzamiento. Eso significa que la llamada que comprueba el saldo desaparecerá en la versión de lanzamiento. Para resolver este problema, debe reemplazar Debug.Assert con Trace.Assert, que no desaparece en la versión de lanzamiento:

A diferencia de las llamadas a Debug.Assert, las llamadas a Trace.Assert agregan sobrecarga a la versión de lanzamiento.

Efectos secundarios de Debug.Assert

Cuando utilice Debug.Assert, asegúrese de que, si se quita el código de Assert, no cambia el resultado del programa. De lo contrario, podría producir accidentalmente un error que sólo aparecerá en la versión de lanzamiento del programa. Preste especial atención a las instrucciones Assert que contienen llamadas a funciones o procedimientos, como en el ejemplo siguiente:

[Visual Basic]

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

[C#]

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

Esta utilización de Debug.Assert parece segura a primera vista, pero suponga que cada vez que se llama a la función meas se actualiza un contador. Cuando se genera la versión de lanzamiento, esta llamada a meas se elimina, de manera que no se actualiza el contador. Éste es un ejemplo de función con un efecto secundario. Cuando se elimina una llamada a una función que tiene efectos secundarios puede producirse un error que sólo aparece en la versión de lanzamiento. Para evitar tales problemas, no incluya llamadas a funciones en una instrucción Debug.Assert. En su lugar utilice una variable temporal:

[Visual Basic]

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

[C#]

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

Aunque se utilice Trace.Assert, podría ser conveniente evitar colocar las llamadas a funciones dentro de una instrucción Assert. Tales llamadas deben ser seguras, puesto que las instrucciones Trace.Assert no se eliminan de la versión de lanzamiento. No obstante, si se acostumbra a evitar tales construcciones, la probabilidad de cometer un error al utilizar Debug.Assert será menor.

Requisitos de Trace y Debug

Si crea el proyecto mediante asistentes de Visual Studio, el símbolo TRACE se define de forma predeterminada tanto en la configuración Release como en la configuración Debug. El símbolo DEBUG se define de forma predeterminada en la versión de depuración.

De lo contrario, para que los métodos Trace funcionen, el programa debe tener uno de los símbolos siguientes en la parte superior del archivo de código fuente:

• #Const TRACE = True en Visual Basic

• #define TRACE en Visual C# y C++

O bien, el programa debe integrar la opción TRACE:

• /d:TRACE=True en Visual Basic

• /d:TRACE en Visual C# y C++

Si necesita utilizar los métodos Debug en la versión de lanzamiento de C# o Visual Basic, debe definir el símbolo DEBUG en la configuración Release.

C++ no admite los métodos de clase Debug. Se puede conseguir el mismo efecto mediante la clase Trace con compilación condicional, por ejemplo #ifdef DEBUG. #endif. Estos símbolos se pueden definir en el cuadro de diálogo Páginas de propiedades de <proyecto>. Para obtener más información, vea Cambiar la configuración del proyecto para una configuración de depuración de Visual Basic o Cambiar la configuración del proyecto para una configuración de depuración de C o C++.

Argumentos de Assert

Trace.Assert y Debug.Assert pueden utilizar hasta tres argumentos. El primero, de uso obligatorio, es la condición que se desea comprobar. Si llama a Trace.Assert(Boolean) o Debug.Assert(Boolean) con un único argumento, el método Assert comprueba la condición y, si el resultado es false, envía el contenido de la pila de llamadas a la Ventana de salida. El ejemplo siguiente muestra Trace.Assert(Boolean) y Debug.Assert(Boolean).

[Visual Basic]

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

[C#]

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

Los argumentos segundo y tercero, si existen, deben ser cadenas. Si llama a Trace.Assert o Debug.Assert con dos o tres argumentos, el primer argumento es una condición. El método comprueba la condición y, si el resultado es false, genera la segunda y tercera cadena. El ejemplo siguiente muestra Debug.Assert(Boolean, String) y Trace.Assert(Boolean, String) utilizados con dos 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" );

El ejemplo siguiente muestra Assert y 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" ); 

Personalizar el comportamiento de Assert

Si se ejecuta la aplicación en modo de interfaz de usuario, el método Assert muestra el cuadro de diálogo Error de aserción cuando se produce un error en la condición. Las propiedades Listeners o Listeners controlan las acciones que tienen lugar cuando se produce un error en una aserción.

Para personalizar el comportamiento del resultado, se puede agregar un objeto TraceListener a la colección Listeners, quitar un objeto TraceListener de la colección Listeners o reemplazar el método TraceListener.Fail de un objeto TraceListener existente para que se comporte de forma diferente.

Por ejemplo, podría reemplazar el método TraceListener.Fail para escribir en un registro de eventos, en lugar de mostrar el cuadro de diálogo Error de aserción.

Para personalizar el resultado de esta forma, el programa debe contener un agente de escucha, heredar de TraceListener y reemplazar el método TraceListener.Fail.

Para obtener más información, vea Agentes de escucha de seguimiento.

Establecer aserciones en archivos de configuración

Se pueden establecer aserciones en el archivo de configuración del programa al igual que en el código. Para obtener más información, vea Trace.Assert o Debug.Assert.

Vea también

Tareas

Cómo: Realizar compilación condicional con Trace y Debug

Referencia

Debug.Assert

Trace.Assert

Conceptos

Seguridad del depurador

Otros recursos

Seguimiento e instrumentación de aplicaciones

Preparación de la depuración: Tipos de proyectos de C#, F# y Visual Basic

Depurar código administrado