Posso scoprire il valore restituito prima di tornare durante il debug in Eclipse?

StackOverflow https://stackoverflow.com/questions/217116

Domanda

È possibile visualizzare il valore restituito di un metodo dopo che la riga è stata eseguita e prima che il puntatore dell'istruzione ritorni alla funzione chiamante?

Sto eseguendo il debug del codice non riesco a modificare (leggi: non voglio ricompilare una libreria di terze parti) , e talvolta passa al codice che non ho sorgente o l'espressione di ritorno ha effetti collaterali che mi impediscono di eseguire semplicemente l'espressione nella scheda Visualizza .

Spesso il valore restituito viene utilizzato in un'istruzione composta, quindi la vista Variabili non mi mostrerà mai il valore (quindi voler vedere il risultato prima che il controllo ritorni alla funzione chiamante).

AGGIORNAMENTO: Non riesco a utilizzare il visualizzatore di espressioni in quanto vi sono effetti collaterali nell'istruzione.

È stato utile?

Soluzione

Questa funzione è stata aggiunta a Eclipse versione 4.7 M2 in Eclipse bug 40912 .

Per usarlo:

  • verifica l'istruzione return (utilizzando " Step Over " oppure " Step Return ")
  • ora la prima riga nella vista variabile mostrerà il risultato dell'istruzione return, come " [istruzione xxx] restituita: "

Vedi Eclipse Project Oxygen (4.7) M2 - Novità e degno di nota per i dettagli.

Altri suggerimenti

Trovato un ottimo collegamento per questo. Seleziona l'espressione che restituisce il valore e premi 

Ctrl + Shift + D

Verrà visualizzato il valore dell'istruzione return. Questo è davvero utile nei casi in cui non è possibile o non si desidera modificare solo a scopo di debug.

Spero che questo aiuti.

Nota: non ho provato questo con librerie di terze parti, ma funziona bene per il mio codice. Testato su IDE Java EE di Eclipse per sviluppatori Web. Versione: Juno Service Release 1

Questo è in realtà un bug di vecchia data in Eclipse, che risale ai primissimi giorni dell'IDE: https://bugs.eclipse.org/bugs/show_bug.cgi?id=40912

Ecco perché seguo sempre il seguente schema per i metodi: 

MyReturnedType foo() {
     MyReturnedType   result = null;

     // do your stuff, modify the result or not

     return result;
}

Le mie regole:

  1. Solo una dichiarazione di ritorno, solo alla fine del metodo (finalmente permesso dopo)
  2. Avere sempre un risultato chiamato local che contiene il valore restituito, a partire da un valore predefinito.

Naturalmente, i getter più banali sono esenti.

Sono curioso di imparare anche la risposta a questa domanda.

In passato, quando ho avuto a che fare con una libreria di terze parti in quel modo, quello che ho fatto è stato creare una classe wrapper o una classe child che delegasse alla classe parent e fare il mio debug nella classe wrapper / child. Ci vuole lavoro extra però.

" Ora quando torni da un metodo, nel metodo superiore, nella vista variabile mostra il valore di ritorno della chiamata precedentemente terminata " [1]

[1] https: / /coffeeorientedprogramming.wordpress.com/2016/09/23/eclipse-see-return-value-during-debugging/

Uno duro. La mia esperienza, al di fuori di Eclipse, è che se potrebbe essere necessario visualizzare il valore restituito, è meglio assegnarlo a una variabile locale nella funzione in modo che l'istruzione return sia un semplice return varname; e non return (alcune * espressioni || altro); . Tuttavia, ciò non è terribilmente utile poiché dici che non puoi (o non vuoi) modificare o persino ricompilare il codice. Quindi, non ho una buona risposta per te - forse devi riconsiderare le tue esigenze.

A seconda dell'istruzione return, puoi evidenziare l'espressione che viene restituita e dal menu di scelta rapida, dovrebbe esserci qualcosa come "valuta l'espressione"; (Non ho eclissi davanti a me adesso, ma è qualcosa del genere). Ti mostrerà cosa verrà restituito.

Questo è un po 'inverosimile, ma poiché non sembra esserci un modo semplice:

Potresti usare AspectJ per strumentare il JAR con aspetti che ottengono il valore di ritorno dei metodi che ti interessano. Secondo la documentazione di Eclipse, i programmi AspectJ possono essere debugged come altri programmi.

Esistono due opzioni per intrecciare le classi senza ricompilare la libreria:

  • Tessitura post-compilazione se l'elaborazione del JAR binario è accettabile;

  • Tessitura a tempo di carico, che richiede l'attivazione di un agente di tessitura nella VM.

Consulta la documentazione di eclipse (link sopra) e anche AspectJ Development Guida ambientale .

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top