Überprüfen von Rückgabewerten der Methodenaufrufe

Im Fenster Auto können Sie die Rückgabewerte der .NET Framework- und C++-Methoden überprüfen, wenn Sie einen Methodenaufruf überspringen oder die schrittweise Ausführung des Methodenaufrufs beenden. Diese Funktion ist nützlich, wenn das Ergebnis eines Methodenaufrufs nicht in einer lokalen Variablen gespeichert wird, z. B. wenn eine Methode als Parameter oder Rückgabewert einer anderen Methode verwendet wird.

Inhalt

Anzeigen der Rückgabewerte von Methoden im Fenster "Auto"

Anzeigen der Rückgabewerte der .NET Framework-Methode in den Fenstern "Direkt" und "Überwachen"

Anzeigen der Rückgabewerte von Methoden im Fenster "Auto"

1. Erstellen Sie eine C#- oder C++-Konsolenanwendung.

2. Ersetzen Sie die Main-C#-Methode oder die _tmain-C++-Methode durch den folgenden Code:

   //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. Legen Sie Haltepunkte für den Aufruf von Method1 und Method2 in der Main-Methode fest.

4. Klicken Sie im Menü Debuggen auf Debuggen starten (Tastatur: F5), um das Debugging zu starten und den Aufruf von Method1 zu unterbrechen.

5. Wählen Sie Debuggen, Einzelschritt (Tastatur: F10), um Method1 zu öffnen.

6. Wählen Sie Debuggen, Prozedurschritt (Tastatur: F11), um die erste Codezeile von "Method1" zu überspringen.

7. Beachten Sie im Fenster Auto, dass die Rückgabewerte der Multiply-, FourTimes-, Five- und Six-Methoden angezeigt werden und das Rückgabewertsymbol enthalten. (Zum Öffnen des Fensters Auto wählen Sie Debuggen, Fenster, Auto aus, oder drücken Sie STRG+ALT+V, A.)

   

8. Wählen Sie Debuggen, Weiter (Tastatur: F5), um die Ausführung bis zum Aufruf von Method2 fortzusetzen.

9. Führen Sie einen Einzelschritt in Method2 aus.

10. Überspringen Sie die Return-Anweisung.

11. Beachten Sie, dass im Fenster Auto der Rückgabewert der Five-Methode angezeigt wird (der direkt von "Method2" zurückgegebene Wert).

    

Anzeigen der Rückgabewerte der .NET Framework-Methode in den Fenstern "Direkt" und "Überwachen"

Sie können den Rückgabewert eines .NET Framework-Methodenaufrufs auch überprüfen, indem Sie im Fenster Direkt oder in einem Überwachungsfenster den Wert $ReturnValue eingeben, nachdem Sie den Methodenaufruf übersprungen oder die schrittweise Ausführung des Methodenaufrufs beendet haben. Um das Fenster Direkt zu öffnen, wählen Sie Debuggen, Fenster, Direkt aus (Tastatur: STRG+ALT+I).