Romper cuando un valor cambia usando el depurador de Visual Studio

¿Hay alguna manera de colocar un reloj en la variable y solo hacer que Visual Studio se rompa cuando ese valor cambia?

Haría mucho más fácil encontrar problemas de estado difíciles.

Se puede hacer esto?

Las condiciones de punto de interrupción todavía necesitan un conjunto de puntos de interrupción, y prefiero establecer un reloj y dejar que Visual Studio establezca los puntos de interrupción en los cambios de estado.

En el menú de Visual Studio 2005:

Depuración -> Nuevo punto de interrupción -> Nuevo punto de interrupción de datos

Entrar:

&myVariable

También puede optar por romper explícitamente en el código:

// Assuming C#
if (condition)
{
    System.Diagnostics.Debugger.Break();
}

De MSDN:

Debugger.Break: si no se adjunta ningún depurador, se pregunta a los usuarios si desean adjuntar un depurador. En caso afirmativo, se inicia el depurador. Si se adjunta un depurador, el depurador se señala con un evento de punto de interrupción del usuario, y el depurador suspende la ejecución del proceso como si se hubiera alcanzado un punto de interrupción del depurador.

Sin embargo, esto es solo una alternativa. Establecer un punto de interrupción condicional en Visual Studio, como se describe en otros comentarios, es una mejor opción.

Publicación muy antigua pero en caso de que alguien no se dé cuenta ...

En Visual Studio 2015 , puede colocar un punto de interrupción en el setdescriptor de acceso de una propiedad implementada automáticamente y el depurador se interrumpirá cuando se actualice la propiedad

public bool IsUpdated
{
    get;
    set;    //set breakpoint on this line
}

Actualizar

Alternativamente; @AbdulRaufMujahid ha señalado en los comentarios que si la propiedad implementada automáticamente está en una sola línea, puede colocar el cursor en get;o set;y presionar F9y se colocará un punto de interrupción en consecuencia. ¡Agradable!

public bool IsUpdated { get; set; }

Imagine que tiene una clase llamada A con la siguiente declaración.

class A  
{  
    public:  
        A();

    private:
        int m_value;
};

Desea que el programa se detenga cuando alguien modifique el valor de "m_value".

Vaya a la definición de clase y ponga un punto de interrupción en el constructor de A.

A::A()
{
    ... // set breakpoint here
}

Una vez que detuvimos el programa:

Depuración -> Nuevo punto de interrupción -> Nuevo punto de interrupción de datos ...

Dirección: & (this-> m_value)
Recuento de bytes: 4 (porque int tiene 4 bytes)

Ahora, podemos reanudar el programa. El depurador se detendrá cuando se cambie el valor.

Puede hacer lo mismo con clases heredadas o clases compuestas.

class B
{
   private:
       A m_a;
};

Dirección: & (this-> m_a.m_value)

Si no conoce el número de bytes de la variable que desea inspeccionar, puede usar el operador sizeof.

Por ejemplo:

// to know the size of the word processor,  
// if you want to inspect a pointer.
int wordTam = sizeof (void* ); 

Si observa la "Pila de llamadas", puede ver la función que cambió el valor de la variable.

Cambie la variable a una propiedad y agregue un punto de interrupción en el método establecido. Ejemplo:

private bool m_Var = false;
protected bool var
{
    get { 
        return m_var;
    }

    set { 
        m_var = value;
    }
}

Si está utilizando WPF, hay una herramienta increíble: WPF Inspector .
Se adjunta a una aplicación WPF y muestra el árbol completo de controles con todas las propiedades, y le permite (entre otras cosas) interrumpir cualquier cambio de propiedad.

Pero lamentablemente no encontré ninguna herramienta que te permitiera hacer lo mismo con CUALQUIER propiedad o variable.

Recuerdo la forma en que lo describiste usando Visual Basic 6.0 . En Visual Studio, la única forma que he encontrado hasta ahora es especificando una condición de punto de interrupción .

Hacer clic derecho en el punto de interrupción funciona bien para mí (aunque sobre todo lo estoy usando para puntos de interrupción condicionales en valores de variables específicas. Incluso romper en expresiones que involucran un nombre de subproceso funciona, lo cual es muy útil si está tratando de detectar problemas de subprocesamiento).

Como Peter Mortensen escribió:

En el menú de Visual Studio 2005:

Depuración -> Nuevo punto de interrupción -> Nuevo punto de interrupción de datos

Ingrese: & myVariable

Información Adicional:

Obviamente, el sistema debe saber qué dirección en la memoria mirar. Entonces, establezca un punto de interrupción normal para la inicialización de myVariable(o myClass.m_Variable), ejecute el sistema y espere hasta que se detenga en ese punto de interrupción. - Ahora la entrada del menú está habilitada, y puede ver la variable ingresando &myVariable, o la instancia ingresando &myClass.m_Variable. Ahora las direcciones están bien definidas.

Lo siento cuando hice las cosas mal al explicar una solución ya dada. Pero no pude agregar un comentario, y ha habido algunos comentarios al respecto.

Puede usar un punto de observación de memoria en código no administrado. Sin embargo, no estoy seguro de si están disponibles en el código administrado.

Probablemente pueda hacer un uso inteligente de la función DebugBreak () .

Opcionalmente, puede sobrecargar el operador = para la variable y puede poner el punto de interrupción dentro de la función sobrecargada en una condición específica.

Actualización en 2019:

Esto ahora es oficialmente compatible con Visual Studio 2019 Preview 2 para .Net Core 3.0 o superior. Por supuesto, es posible que tenga que reflexionar sobre los riesgos potenciales de usar una versión de IDE de vista previa. Me imagino que en un futuro próximo esto se incluirá en el Visual Studio oficial.

https://blogs.msdn.microsoft.com/visualstudio/2019/02/12/break-when-value-changes-data-breakpoints-for-net-core-in-visual-studio-2019/

¡Afortunadamente, los puntos de corte de datos ya no son exclusivos de C ++ porque ahora están disponibles para .NET Core (3.0 o superior) en Visual Studio 2019 Preview 2!