Esaminare i valori restituiti dalle chiamate di metodo

Nella finestra Auto è possibile esaminare i valori restituiti dei metodi .NET Framework e C++ quando si eseguono istruzioni/routine della chiamata a un metodo o si esce dalla chiamata. Questa funzionalità è utile quando il risultato di una chiamata al metodo non è archiviata in una variabile locale, ad esempio quando un metodo viene utilizzato come parametro o valore restituito di un altro metodo.

Contenuto

Visualizzare valori restituiti dal metodo nella finestra Auto

Visualizzare valori restituiti dal metodo .NET Framework nelle finestre Controllo immediato ed Espressioni di controllo

Visualizzare valori restituiti dal metodo nella finestra Auto

1. Creare un'applicazione console in C# o C++.

2. Sostituire il metodo C# Main o il metodo C++ _tmain con il codice riportato di seguito.

   //static void Main(string[] args) {
       Method1();         // 1. Set a breakpoint here
                          // 2. Then step into Method1 
       int y = Method2(); // 3. Set a breakpoint here
                          // 4. Then step into Method2 
   
   static void Method1(){
       // 1. Step over the following line
       int result = Multiply(FourTimes(Five()), Six());
       // 2. Then view the return values in the Autos window
   }
   
   static int Method2(){
       // 1. Step over the following line
       return Five();
       // 2. Then view the return values in the Autos window
   }
   
   static int Multiply(int x, int y){
       return x * y;
   }
   
   static int FourTimes(int x){
       return 4 * x;
   }
   
   static int Five(){
       return 5;
   }
   
   static int Six(){
       return 6;
   }
   

   void Method1();
   int Method2();
   int Multiply(int x, int y);
   int FourTimes(int x);
   int Five();
   int Six();
   
   int _tmain(int argc, _TCHAR* argv[])
   {
       Method1();            // 1. Set a breakpoint here
                             // 2. Then step into Method1 
       int x = Method2();    // 3. Set a breakpoint here
                             // 4. Then step into Method2 
   }
   
   void Method1(){
       // 1. Step over the following line
       int result = Multiply(FourTimes(Five()), Six());
       // 2. Then view the return values in the Autos window
   }
   
   int Method2(){
       // 1. Step over the following line
       return Five();
       // 2. Then view the return values in the Autos window
   }
   
   int Multiply(int x, int y){
       return x * y;
   }
   
   int FourTimes(int x){
       return 4 * x;
   }
   
   int Five(){
       return Six();
   }
   
   int Six(){
       return 6;
   }
   

3. Impostare i punti di interruzione in corrispondenza delle chiamate a Method1 e Method2 nel metodo Main.

4. Scegliere Avvia debug dal menu Debug (tastiera: F5) per avviare il debug e inserire un'interruzione in corrispondenza della chiamata a Method1.

5. Scegliere Debug, Esegui istruzione (tastiera: F10) per immettere Method1.

6. Scegliere Debug, Esegui istruzione/routine (tastiera: F11) per ignorare la prima riga di codice di Method1.

7. Nella finestra Auto si noti che vengono visualizzati i valori restituiti dei metodi Multiply, FourTimes, Five e Six in cui è inclusa l'icona del valore restituito. Per aprire la finestra Auto, scegliere Debug, Windows, Auto o premere CTRL + ALT + V, A.

   

8. Scegliere Debug, Continua (tastiera: F5) per continuare l'esecuzione fino alla chiamata a Method2.

9. Eseguire l'istruzione di Method2.

10. Ignorare l'istruzione return.

11. Si noti che nella finestra Auto viene visualizzato il valore restituito del metodo Five, che viene restituito direttamente da Method2.

    

Visualizzare valori restituiti dal metodo .NET Framework nelle finestre Controllo immediato ed Espressioni di controllo

È inoltre possibile esaminare il valore restituito di una chiamata al metodo .NET Framework digitando $ReturnValue nella finestra Controllo immediato o in una finestra Espressioni di controllo dopo avere ignorato o essere usciti dalla chiamata al metodo. Per aprire la finestra Controllo immediato, scegliere Debug, Windows, Controllo immediato (tastiera: CTRL + ALT + I).