Interruzione quando un valore cambia utilizzando il debugger di Visual Studio

C'è un modo per posizionare un watch su variabile e interrompere Visual Studio solo quando quel valore cambia?

Sarebbe molto più facile trovare problemi di stato difficili.

Può essere fatto?

Le condizioni di breakpoint necessitano ancora di un set di breakpoint, e preferirei impostare un watch e lasciare che Visual Studio imposti i breakpoint ai cambi di stato.

Nel menu di Visual Studio 2005:

Debug -> Nuovo punto di interruzione -> Nuovo punto di interruzione dati

Accedere:

&myVariable

Puoi anche scegliere di rompere esplicitamente nel codice:

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

Da MSDN:

Debugger.Break: se non è collegato alcun debugger, agli utenti viene chiesto se desiderano collegare un debugger. In caso affermativo, il debugger viene avviato. Se è collegato un debugger, il debugger viene segnalato con un evento breakpoint utente e il debugger sospende l'esecuzione del processo come se fosse stato raggiunto un breakpoint debugger.

Questo è solo un fallback, però. L'impostazione di un breakpoint condizionale in Visual Studio, come descritto in altri commenti, è una scelta migliore.

Post davvero vecchio ma nel caso qualcuno non lo sappia ...

In Visual Studio 2015 , è possibile posizionare un punto di interruzione sull'accessorio setdi una proprietà implementata automaticamente e il debugger si interromperà quando la proprietà viene aggiornata

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

Aggiornare

In alternativa; @AbdulRaufMujahid ha sottolineato nei commenti che se la proprietà implementata automaticamente si trova su una singola riga, è possibile posizionare il cursore su get;o set;e premere F9e un punto di interruzione verrà posizionato di conseguenza. Bello!

public bool IsUpdated { get; set; }

Immagina di avere una classe chiamata A con la seguente dichiarazione.

class A  
{  
    public:  
        A();

    private:
        int m_value;
};

Volete fermare il programma quando qualcuno modifica il valore di "m_value".

Vai alla definizione della classe e metti un breakpoint nel costruttore di A.

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

Una volta interrotto il programma:

Debug -> Nuovo punto di interruzione -> Nuovo punto di interruzione dati ...

Indirizzo: & (this-> m_value)
Conteggio byte: 4 (Perché int ha 4 byte)

Ora, possiamo riprendere il programma. Il debugger si arresterà quando il valore viene modificato.

Puoi fare lo stesso con le classi ereditate o le classi composte.

class B
{
   private:
       A m_a;
};

Indirizzo: & (this-> m_a.m_value)

Se non si conosce il numero di byte della variabile che si desidera controllare, è possibile utilizzare l'operatore sizeof.

Per esempio:

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

Se guardi lo "Stack di chiamate" puoi vedere la funzione che ha cambiato il valore della variabile.

Modificare la variabile in una proprietà e aggiungere un punto di interruzione nel metodo set. Esempio:

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

    set { 
        m_var = value;
    }
}

Se stai usando WPF, c'è uno strumento fantastico: WPF Inspector .
Si collega a un'app WPF e visualizza l'intera struttura dei controlli con tutte le proprietà, e consente (tra le altre cose) di interrompere qualsiasi modifica di proprietà.

Ma purtroppo non ho trovato nessuno strumento che ti permettesse di fare lo stesso con QUALSIASI proprietà o variabile.

Ricordo il modo in cui l'hai descritto usando Visual Basic 6.0 . In Visual Studio, l'unico modo che ho trovato finora è specificando una condizione di breakpoint .

Fare clic con il tasto destro del mouse sul punto di interruzione funziona bene per me (anche se principalmente lo sto usando per punti di interruzione condizionali su valori variabili specifici. Anche l'interruzione di espressioni che coinvolgono un nome di thread funziona molto utile se si sta cercando di individuare problemi di threading).

Come scrisse Peter Mortensen:

Nel menu di Visual Studio 2005:

Debug -> Nuovo punto di interruzione -> Nuovo punto di interruzione dati

Immettere: & myVariable

Informazioni aggiuntive:

Ovviamente, il sistema deve sapere quale indirizzo in memoria guardare. Quindi - imposta un normale punto di interruzione sull'inizializzazione di myVariable(o myClass.m_Variable) - avvia il sistema e attendi fino a quando non si ferma a quel punto di interruzione. - Ora la voce di menu è abilitata e puoi guardare la variabile inserendo &myVariableo l'istanza inserendo&myClass.m_Variable . Ora gli indirizzi sono ben definiti.

Scusate quando ho fatto cose sbagliate spiegando una soluzione già fornita. Ma non ho potuto aggiungere un commento, e ci sono stati alcuni commenti a riguardo.

È possibile utilizzare un watchpoint di memoria nel codice non gestito. Non sono sicuro che siano disponibili nel codice gestito.

Probabilmente puoi fare un uso intelligente della funzione DebugBreak () .

Se lo si desidera, è possibile sovraccaricare l'operatore = per la variabile e posizionare il punto di interruzione all'interno della funzione di sovraccarico su una condizione specifica.

Aggiornamento nel 2019:

Questo è ora ufficialmente supportato in Visual Studio 2019 Preview 2 per .Net Core 3.0 o versione successiva. Naturalmente, potresti dover pensare ad alcuni rischi potenziali nell'utilizzo di una versione di anteprima di IDE. Immagino che nel prossimo futuro questo sarà incluso nel Visual Studio ufficiale.

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

Fortunatamente, i punti di interruzione dei dati non sono più un'esclusiva C ++ perché ora sono disponibili per .NET Core (3.0 o versione successiva) in Visual Studio 2019 Preview 2!