Posso scoprire il valore restituito prima di tornare durante il debug in Visual Studio?
https://stackoverflow.com/questions/268048
-
06-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Prendi la seguente funzione:
DataTable go() {
return someTableAdapter.getSomeData();
}
Quando imposto un breakpoint in questa funzione, c'è la possibilità di ispezionare il valore restituito? go () è direttamente accoppiato a un datagrid in una pagina .aspx .
L'unico modo per ispezionare il datatable restituito è utilizzare una variabile temporanea. Tuttavia, è un po 'scomodo. Non c'è un altro modo?
Soluzione
Non che io sappia. Nota che se fai aggiungi una variabile, verrà comunque rimossa dal compilatore nelle build di rilascio ...
Aggiornamento:
Questa funzionalità è stata aggiunta a VS2013 .
Puoi vedere i valori di ritorno nelle finestre delle auto o usare $ ReturnValue nella finestra watch / immediate.
Il valore può essere visualizzato direttamente dopo il ritorno dalla funzione, quindi il modo più semplice per accedervi è inserire un punto di interruzione nella chiamata di funzione e passare (F10) alla chiamata.
Aggiornamento per VS2015: boo! sfortunatamente, non sembra essere in VS2015 (devenv v14)
Aggiornamento per VS2017: è tornato. (devenv v15)
Altri suggerimenti
Questo può essere fatto in Visual Studio 2013 con CLR 4.5.1 secondo il sito di feedback dei clienti . Non era disponibile nelle versioni precedenti per C #.
(Visual & nbsp; Studio & nbsp; 2008 e precedenti l'hanno supportato per VB.NET. È sempre stato disponibile per gli sviluppatori C / C ++.)
Sono d'accordo sul fatto che questa è una cosa molto utile da avere: non solo vedere il valore di ritorno del metodo prima di uscirne, ma anche vedere il valore di ritorno dei metodi che ho appena superato. L'ho implementato come parte di un'estensione commerciale di Visual Studio denominata " OzCode " ;.
Con esso, puoi visualizzare i valori di ritorno del metodo direttamente sull'editor di codice, come una sorta di display HUD:
Per ulteriori informazioni, consulta questo video .
Secondo Microsoft, non c'è modo di implementarlo in modo affidabile con il codice gestito. Questo è un problema di cui sono a conoscenza e su cui stanno lavorando:
Per quelli là fuori che hanno esperienza nel debug del codice C ++ o VB6 nativo, potresti aver usato una funzione in cui i valori di ritorno della funzione sono forniti nella finestra Autos. Sfortunatamente, questa funzionalità non esiste per il codice gestito. Sebbene sia possibile aggirare questo problema assegnando i valori restituiti a una variabile locale, ciò non è altrettanto conveniente perché richiede la modifica del codice. Nel codice gestito, è molto più difficile determinare quale sia il valore di ritorno di una funzione che hai superato. Ci siamo resi conto che non potevamo fare la cosa giusta in modo coerente qui e quindi abbiamo rimosso la funzione piuttosto che darti risultati errati nel debugger. Tuttavia, vogliamo riportarlo indietro per voi e i nostri team CLR e Debugger stanno esaminando una serie di potenziali soluzioni a questo problema. Purtroppo questo non farà parte di Visual Studio 11.
Secondo la risposta attualmente accettata da Marc Gravell:
Questo è stata aggiunta a Visual & nbsp; Studio & nbsp; 2013 . Puoi vedere il ritorno valori nelle finestre delle auto o utilizzare $ ReturnValue nell'orologio / immediato finestra
La risposta affermava inoltre che questa funzionalità non funziona in Visual & nbsp; Studio & nbsp; 2015. Questo non è (interamente) vero. Su Esamina i valori di ritorno delle chiamate di metodo c'è la seguente nota:
È necessario che i valutatori di espressioni legacy siano attivati ??affinché $ ReturnValue sia riconosciuto (Strumenti / Opzioni / Debug / Usa i valutatori di espressioni C # e VB legacy ). Altrimenti, puoi utilizzare $ ReturnValue1 .
Ho provato questo in Visual & nbsp; Studio & nbsp; 2015 Enterprise:
- Con i valutatori di espressioni legacy disattivati: solo $ ReturnValue1 funziona
- Con i valutatori di espressioni legacy attivati: entrambi $ ReturnValue e $ ReturnValue1 funzionano
Se vai al menu Strumenti & # 8594; Opzioni , IntelliTrace e modifica l'impostazione per raccogliere eventi e informazioni sulla chiamata.
Puoi tornare all'evento di chiamata precedente ( Ctrl + Maiusc + F11 ) e vedere il valore temporaneo restituito dalla chiamata del metodo nella finestra delle auto come figlio del nome del metodo.
Questo non ti mostra il valore di ritorno per il metodo in cui ti trovi. Ti mostra solo il valore di ritorno dell'ultimo metodo chiamato nel metodo corrente.
Quindi, va bene per
DataTable go(){return someTableAdapter.getSomeData();}
poiché mostra il valore restituito per someTableAdapter.getSomeData () .
Ma non per:
int go(){return 100 * 99;}
Vecchio trucco dai giorni precedenti a .NET: apri la finestra Registri e osserva il valore del registro EAX. Questo contiene il valore restituito dell'ultima funzione chiamata.
Esci dal metodo go () usando Shift-F11, quindi nel " Auto " finestra di debug mostrerà il valore di ritorno della chiamata del metodo che è appena saltato fuori dallo stack (in questo caso, il metodo go () che è quello che vuoi). Questo è il comportamento in Visual Studio 2005; Non ho usato Visual Studio 2008, quindi non so se questo si comporti allo stesso modo in quella versione.
Sì, c'è un modo molto carino. Uno svantaggio significativo è che dovresti aspettare 5, forse 6 anni. Dal momento che vedo che hai pubblicato nel novembre 2008, ti suggerisco di waaaaaa ...
... aaaait. E voil & # 224 ;! Solo per te, MS ha rilasciato l'ultimo Visual Studio 2013 in cui è una funzionalità predefinita accessibile dai menu durante l'esecuzione in modalità debug (menu Debug & # 8594; Windows & # 8594; Auto ).
Esistono molte soluzioni alternative, ma nessuna sembra soddisfacente.
Per citare John Skeet di seguito (commentare una risposta ora cancellata):
Mi sembra ancora scomodo - soprattutto se non sai quale valore di ritorno che ti servirà prima di iniziare il debug. Io davvero non voglio avere un temporaneo variabile ingombra il mio codice ogni volta che mai restituire nulla.t
In teoria, il debugger potrebbe avere una variabile return . Dopotutto: è solo una variabile nello stack:
unsafe {
int * sp = stackalloc int[1];
try {
return a+b;
}
finally {
Trace.WriteLine("return is " + *(sp+3));
}
}
Quindi considera questa una richiesta di funzionalità per Visual Studio.
Microsoft Visual C ++ era solito farlo, ma Visual Studio non ha AFAIK .. :(
L'unico modo che conosco è posizionare un punto di interruzione sulla linea di ritorno e quindi chiamare la finestra Quick Watch e inserire l'espressione restituita:
someTableAdapter.getSomeData();
Ma questo funziona solo se la chiamata non cambia lo stato di nessun oggetto (poiché ci sarà una seconda chiamata allo stesso metodo quando riprenderai l'esecuzione).
Volevo espandermi su La risposta di PascalK per farlo funzionare in Visual & nbsp; Studio & nbsp; 2015, perché esiste una funzione nascosta che non è documentata in Esamina i valori di ritorno delle chiamate di metodo .
Se hai chiamate di funzione nidificate, le pseudo-variabili $ ResultValueX vengono create automaticamente, dove la X si riferisce all'ordine di chiamata della funzione. Quindi se hai una chiamata come Moltiplica (cinque (), sei ()) , vengono create le seguenti pseudo-variabili:
Five() | $ResultValue1 = 5
Six() | $ResultValue2 = 6
Multiply() | $ResultValue3 = 30
Puoi anche chiedere di valutare il valore anche nella finestra intermedia, se non imposta flag o altre variabili, ma restituisce solo qualcosa.
Penso che sia possibile determinarlo osservando il registro RAX nella finestra Registri (Debug / Windows / Registri). Dopo essere usciti (MAIUSC + F11) della funzione, controllare il registro RAX. Non lo so per certo, ma una volta sulla luna potresti controllare un registro (giorni precedenti .NET) e vedere lì il valore di ritorno. Potrebbe anche essere una combinazione di RAX e RBX, ecc.
L'apertura della finestra Debug ? Auto ti avvicina. Non mostrerà il valore restituito effettivo, ma mostrerà ciò che è stato valutato nell'istruzione return.
Sì, passando a VB.NET. ; P (Hai appena detto " Visual Studio " ;.;)
Per quanto ricordo (da Visual Basic a tutte le versioni di VB.NET), puoi semplicemente interrogare il nome della funzione. "Funziona". come una variabile locale che è implicitamente dichiarata all'inizio della funzione e il suo valore corrente è anche usato come valore di ritorno ogni volta che la funzione esce tramite mezzi di dichiarazione non return (cioè Exit Function o semplicemente fallendo) e, naturalmente, quando viene utilizzata la dichiarazione di ritorno.
È inoltre impostato sull'espressione dell'istruzione return. Proprio come una variabile locale, il suo valore può essere ispezionato in qualsiasi punto di esecuzione all'interno della funzione (anche dopo l'esecuzione dell'istruzione return). C # non ha questo e dovrebbe.
Quella piccola funzionalità VB.NET (più l'istruzione Exit Function che abilita - un'altra funzione che C # non ha e dovrebbe) è molto utile in una forma di programmazione difensiva Pratico dove inizializzo sempre il nome della funzione sul valore di errore / predefinito come prima istruzione. Quindi, in qualsiasi punto di errore (che si verifica molto più spesso dei punti di successo), posso semplicemente chiamare l'istruzione Exit Function (cioè senza dover duplicare l'espressione di errore / default o anche una costante / variabile nome).
La risposta accettata non funziona correttamente con Visual & nbsp; Studio & nbsp; 2015, ma posizionando un punto di interruzione sull'ultima riga del metodo e premendo F10 , verrà inserito tutto espressioni del valore restituito nella finestra dei locali.
Potresti provare a selezionare " someTableAdapter.getSomeData (); " , fai clic destro su di esso e seleziona Quick Watch .
Trascina e rilascia l'espressione di ritorno in una finestra di controllo.
Ad esempio, nell'istruzione
return someTableAdapter.getSomeData();
trascina e rilascia
someTableAdapter.getSomeData()
in una finestra di controllo e vedrai il valore.
Puoi farlo per qualsiasi espressione.
