Procédure pas à pas : Débogage d’une Application parallèle dans Visual StudioWalkthrough: Debugging a Parallel Application in Visual Studio

Cette procédure pas à pas montre comment utiliser le tâches parallèles et piles parallèles windows pour déboguer une application parallèle.This walkthrough shows how to use the Parallel Tasks and Parallel Stacks windows to debug a parallel application. Ces fenêtres vous aident à comprendre et à vérifier le comportement d’exécution de code qui utilise le bibliothèque parallèle de tâches (TPL) ou Runtime d’accès concurrentiel.These windows help you understand and verify the runtime behavior of code that uses the Task Parallel Library (TPL) or the Concurrency Runtime. Cette procédure pas à pas fournit un exemple de code qui comporte des points d'arrêt intégrés.This walkthrough provides sample code that has built-in breakpoints. Une fois que le code s’arrête, la procédure pas à pas montre comment utiliser le tâches parallèles et piles parallèles windows pour l’examiner.After the code breaks, the walkthrough shows how to use the Parallel Tasks and Parallel Stacks windows to examine it.

Cette procédure pas à pas aborde les tâches suivantes :This walkthrough teaches these tasks:

  • Comment afficher les piles d'appels de tous les threads dans une vue.How to view the call stacks of all threads in one view.

  • Comment afficher la liste des instances System.Threading.Tasks.Task créées dans votre application.How to view the list of System.Threading.Tasks.Task instances that are created in your application.

  • Comment afficher les véritables piles d’appels des tâches au lieu des threads.How to view the real call stacks of tasks instead of threads.

  • Comment accéder au code à partir de la tâches parallèles et piles parallèles windows.How to navigate to code from the Parallel Tasks and Parallel Stacks windows.

  • Comment les fenêtres gèrent l’échelle avec les fonctionnalités de regroupement, de zoom et autres.How the windows cope with scale through grouping, zooming, and other related features.

PrérequisPrerequisites

Cette procédure pas à pas suppose que uniquement mon Code est activée (elle est activée par défaut dans les versions plus récentes de Visual Studio).This walkthrough assumes that Just My Code is enabled (it is enabled by default in more recent versions of Visual Studio). Sur le outils menu, cliquez sur Options, développez le débogage nœud, sélectionnez général, puis sélectionnez activer Uniquement mon Code (managé uniquement).On the Tools menu, click Options, expand the Debugging node, select General, and then select Enable Just My Code (Managed only). Si vous ne définissez pas cette fonctionnalité, vous pouvez quand même effectuer cette procédure pas à pas, mais vos résultats peuvent différer de ceux des illustrations.If you do not set this feature, you can still use this walkthrough, but your results may differ from the illustrations.

Exemple C#C# Sample

Si vous utilisez l'exemple C#, cette procédure pas à pas suppose également que le code externe est masqué.If you use the C# sample, this walkthrough also assumes that External Code is hidden. Pour afficher ou masquer le code externe, cliquez sur le nom en-tête de table de la pile des appels fenêtre, puis activez ou désactivez afficher le Code externe.To toggle whether external code is displayed, right-click the Name table header of the Call Stack window, and then select or clear Show External Code. Si vous ne définissez pas cette fonctionnalité, vous pouvez quand même effectuer cette procédure pas à pas, mais vos résultats peuvent différer de ceux des illustrations.If you do not set this feature, you can still use this walkthrough, but your results may differ from the illustrations.

Exemple C++C++ Sample

Si vous utilisez l'exemple C++, vous pouvez ignorer les références au code externe de cette rubrique.If you use the C++ sample, you can ignore references to External Code in this topic. Le code externe s'applique uniquement à l'exemple C#.External Code only applies to the C# sample.

IllustrationsIllustrations

Les illustrations de cette rubrique ont été enregistrées sur un ordinateur quadricœur exécutant l'exemple C#.The illustrations in this topic recorded on a quad core computer running the C# sample. Bien que vous puissiez utiliser d'autres configurations pour effectuer cette procédure pas à pas, les illustrations peuvent différer de celles affichées sur votre ordinateur.Although you can use other configurations to complete this walkthrough, the illustrations may differ from what is displayed on your computer.

Création de l'exemple de projetCreating the Sample Project

L'exemple de code de cette procédure pas à pas est relatif à une application qui ne fait rien.The sample code in this walkthrough is for an application that does nothing. L'objectif est simplement de comprendre comment utiliser les fenêtres Outils pour déboguer une application parallèle.The goal is just to understand how to use the tool windows to debug a parallel application.

Pour créer l'exemple de projetTo create the sample project

  1. Dans Visual Studio, dans le menu Fichier,pointez sur Nouveau, puis cliquez sur Projet.In Visual Studio, on the File menu, point to New and then click Project.

  2. Dans le modèles installés volet, sélectionnez Visual c#, Visual Basic ou Visual C++.In the Installed Templates pane, select either Visual C#, Visual Basic, or Visual C++. Pour les langages managés, assurez-vous que .NET Framework 4 est affiché dans la fenêtre .NET Framework.For the managed languages, ensure that .NET Framework 4 is displayed in the framework box.

  3. Sélectionnez Application Console puis cliquez sur OK.Select Console Application and then click OK. Restez en configuration Debug, qui est la valeur par défaut.Remain in Debug configuration, which is the default.

  4. Ouvrez le fichier de code .cpp, .cs ou .vb dans le projet.Open the .cpp, .cs, or .vb code file in the project. Supprimez son contenu pour créer un fichier de code vide.Delete its contents to create an empty code file.

  5. Collez le code suivant dans le langage choisi dans le fichier de code vide.Paste the following code for your chosen language into the empty code file.

    using System;
    using System.Threading;
    using System.Threading.Tasks;
    using System.Diagnostics;
    
    class S
    {
      static void Main()
      {
        pcount = Environment.ProcessorCount;
        Console.WriteLine("Proc count = " + pcount);
        ThreadPool.SetMinThreads(4, -1);
        ThreadPool.SetMaxThreads(4, -1);
    
        t1 = new Task(A, 1);
        t2 = new Task(A, 2);
        t3 = new Task(A, 3);
        t4 = new Task(A, 4);
        Console.WriteLine("Starting t1 " + t1.Id.ToString());
        t1.Start();
        Console.WriteLine("Starting t2 " + t2.Id.ToString());
        t2.Start();
        Console.WriteLine("Starting t3 " + t3.Id.ToString());
        t3.Start();
        Console.WriteLine("Starting t4 " + t4.Id.ToString());
        t4.Start();
    
        Console.ReadLine();
      }
    
      static void A(object o)
      {
        B(o);
      }
      static void B(object o)
      {
        C(o);
      }
      static void C(object o)
      {
        int temp = (int)o;
    
        Interlocked.Increment(ref aa);
        while (aa < 4)
        {
          ;
        }
    
        if (temp == 1)
        {
          // BP1 - all tasks in C
          Debugger.Break();
          waitFor1 = false;
        }
        else
        {
          while (waitFor1)
          {
            ;
          }
        }
        switch (temp)
        {
          case 1:
            D(o);
            break;
          case 2:
            F(o);
            break;
          case 3:
          case 4:
            I(o);
            break;
          default:
            Debug.Assert(false, "fool");
            break;
        }
      }
      static void D(object o)
      {
        E(o);
      }
      static void E(object o)
      {
        // break here at the same time as H and K
        while (bb < 2)
        {
          ;
        }
        //BP2 - 1 in E, 2 in H, 3 in J, 4 in K
        Debugger.Break();
        Interlocked.Increment(ref bb);
    
        //after
        L(o);
      }
      static void F(object o)
      {
        G(o);
      }
      static void G(object o)
      {
        H(o);
      }
      static void H(object o)
      {
        // break here at the same time as E and K
        Interlocked.Increment(ref bb);
        Monitor.Enter(mylock);
        while (bb < 3)
        {
          ;
        }
        Monitor.Exit(mylock);
    
    
        //after
        L(o);
      }
      static void I(object o)
      {
        J(o);
      }
      static void J(object o)
      {
        int temp2 = (int)o;
    
        switch (temp2)
        {
          case 3:
            t4.Wait();
            break;
          case 4:
            K(o);
            break;
          default:
            Debug.Assert(false, "fool2");
            break;
        }
      }
      static void K(object o)
      {
        // break here at the same time as E and H
        Interlocked.Increment(ref bb);
        Monitor.Enter(mylock);
        while (bb < 3)
        {
          ;
        }
        Monitor.Exit(mylock);
    
    
        //after
        L(o);
      }
      static void L(object oo)
      {
        int temp3 = (int)oo;
    
        switch (temp3)
        {
          case 1:
            M(oo);
            break;
          case 2:
            N(oo);
            break;
          case 4:
            O(oo);
            break;
          default:
            Debug.Assert(false, "fool3");
            break;
        }
      }
      static void M(object o)
      {
        // breaks here at the same time as N and Q
        Interlocked.Increment(ref cc);
        while (cc < 3)
        {
          ;
        }
        //BP3 - 1 in M, 2 in N, 3 still in J, 4 in O, 5 in Q
        Debugger.Break();
        Interlocked.Increment(ref cc);
        while (true)
          Thread.Sleep(500); // for ever
      }
      static void N(object o)
      {
        // breaks here at the same time as M and Q
        Interlocked.Increment(ref cc);
        while (cc < 4)
        {
          ;
        }
        R(o);
      }
      static void O(object o)
      {
        Task t5 = Task.Factory.StartNew(P, TaskCreationOptions.AttachedToParent);
        t5.Wait();
        R(o);
      }
      static void P()
      {
        Console.WriteLine("t5 runs " + Task.CurrentId.ToString());
        Q();
      }
      static void Q()
      {
        // breaks here at the same time as N and M
        Interlocked.Increment(ref cc);
        while (cc < 4)
        {
          ;
        }
        // task 5 dies here freeing task 4 (its parent)
        Console.WriteLine("t5 dies " + Task.CurrentId.ToString());
        waitFor5 = false;
      }
      static void R(object o)
      {
        if ((int)o == 2)
        {
          //wait for task5 to die
          while (waitFor5) { ;}
    
    
          int i;
          //spin up all procs
          for (i = 0; i < pcount - 4; i++)
          {
            Task t = Task.Factory.StartNew(() => { while (true);});
            Console.WriteLine("Started task " + t.Id.ToString());
          }
    
          Task.Factory.StartNew(T, i + 1 + 5, TaskCreationOptions.AttachedToParent); //scheduled
          Task.Factory.StartNew(T, i + 2 + 5, TaskCreationOptions.AttachedToParent); //scheduled
          Task.Factory.StartNew(T, i + 3 + 5, TaskCreationOptions.AttachedToParent); //scheduled
          Task.Factory.StartNew(T, i + 4 + 5, TaskCreationOptions.AttachedToParent); //scheduled
          Task.Factory.StartNew(T, (i + 5 + 5).ToString(), TaskCreationOptions.AttachedToParent); //scheduled
    
          //BP4 - 1 in M, 2 in R, 3 in J, 4 in R, 5 died
          Debugger.Break();
        }
        else
        {
          Debug.Assert((int)o == 4);
          t3.Wait();
        }
      }
      static void T(object o)
      {
        Console.WriteLine("Scheduled run " + Task.CurrentId.ToString());
      }
      static Task t1, t2, t3, t4;
      static int aa = 0;
      static int bb = 0;
      static int cc = 0;
      static bool waitFor1 = true;
      static bool waitFor5 = true;
      static int pcount;
      static S mylock = new S();
    }
    
    #include "stdafx.h"
    #include <windows.h>
    #include <iostream>
    #include <ppl.h>
    #include <agents.h>
    #include <stdio.h>
    #include <concrtrm.h>
    #include <vector>
    
    CRITICAL_SECTION cs;
    
    using namespace ::std;
    using namespace ::std::tr1;
    using namespace ::Concurrency;
    task_group task4;
    task_group task3;
    task_group task2;
    
    volatile long aa = 0;
    volatile long bb = 0;
    volatile long cc = 0;
    static bool waitFor1 = true;
    static bool waitFor5 = true;
    
    #pragma optimize("", off)
    void Spin()
    {
       for(int i=0;i<50*50000;++i);
    }
    #pragma optimize("",on)
    
    template<class Func>
    class RunFunc
    {
       Func& m_Func;
       int m_o;
    public:
       RunFunc(Func func,int o):m_Func(func),m_o(o){
    
       };
       void operator()()const{
          m_Func(m_o);
       };
    };
    
    void T(int o)
    {
       cout << "Scheduled run \n";
    
    };
    
    void R(int o)
    {
       if (o == 2)
       {
          while (waitFor5) { ;}
          Spin();
    
          //use up all processors but 4 by scheduling 4 non-terminating tasks.
          int numProcsToBurn = GetProcessorCount() - 4;
          int i;
          vector<call<int>*> tasks;
          for (i = 0; i <  numProcsToBurn; i++)
          {
             tasks.push_back(new call<int>([](int i){while(true)Spin();}));
             asend(tasks[i],1);
             cout << "Started task  \n";
          }
    
          task_handle<RunFunc<decltype(T)>> t6(RunFunc<decltype(T)>(T,i + 1 + 5));
          task_handle<RunFunc<decltype(T)>> t7(RunFunc<decltype(T)>(T,i + 2 + 5));
          task_handle<RunFunc<decltype(T)>> t8(RunFunc<decltype(T)>(T,i + 3 + 5));
          task_handle<RunFunc<decltype(T)>> t9(RunFunc<decltype(T)>(T,i + 4 + 5));
          task_handle<RunFunc<decltype(T)>> t10(RunFunc<decltype(T)>(T,i + 5 + 5));
          task2.run(t6);
          task2.run(t7);
          task2.run(t8);
          task2.run(t9);
          task2.run(t10);
       
          //BP4 - 1 in M, 2 in R, 3 in J, 4 in R, 5 died   
          DebugBreak();
       }
       else
       {
          if (o!=4)
             throw;
    
          task3.wait();      
       }
    };
    
    void Q()
    {
       // breaks here at the same time as N and M
       InterlockedIncrement(& cc);
       while (cc < 4)
       {
          ;
       }
       // task 5 dies here freeing task 4 (its parent)
       cout << "t5 dies\n";
       waitFor5 = false;
    };
    
    void P()
    {
       cout << "t5 runs\n";
       Q();
    };
    
    void O(int o)
    {   
       task_group t5;
       t5.run(&P);
       t5.wait();
       R(o);
    };
    
    void N(int o)
    {
       // breaks here at the same time as M and Q
       InterlockedIncrement(&cc);
       while (cc < 4)
       {
          ;
       }
       R(o);
    };
    
    void M(int o)
    {
       // breaks here at the same time as N and Q
       InterlockedIncrement(&cc);
       while (cc < 3)
       {
          ;
       }
       //BP3 - 1 in M, 2 in N, 3 still in J, 4 in O, 5 in Q
       DebugBreak();
       InterlockedIncrement(&cc);
       while (true)
          Sleep(500); // for ever
    };
    
    void L(int oo)
    {
       int temp3 = oo;
    
       switch (temp3)
       {
       case 1:
          M(oo);
          break;
       case 2:
          N(oo);
          break;
       case 4:
          O(oo);
          break;
       default:
          throw; //fool3
          break;
       }
    }
    void K(int o)
    {
       // break here at the same time as E and H
       InterlockedIncrement(&bb);
       EnterCriticalSection(&cs);
       while (bb < 3)
       {
          ;
       }
       LeaveCriticalSection(&cs);
       Spin();
    
       //after
       L(o);
    }
    void J(int o)
    {
       int temp2 = o;
    
       switch (temp2)
       {
       case 3:
          task4.wait();
          break;
       case 4:
          K(o);
          break;
       default:
          throw; //fool2
          break;
       }
    }
    static void I(int o)
    {
       J(o);
    }
    static void H(int o)
    {
       // break here at the same time as E and K
       InterlockedIncrement(&bb);
       EnterCriticalSection(&cs);
       while (bb < 3)
       {
          ;
       }
       LeaveCriticalSection(&cs);
       Spin();
    
       //after
       L(o);
    }
    static void G(int o)
    {
       H(o);
    }
    static void F(int o)
    {
       G(o);
    }
    
    static void E(int o)
    {
       // break here at the same time as H and K
       while (bb < 2)
       {
          ;
       }
       //BP2 - 1 in E, 2 in H, 3 in J, 4 in K   
       Spin(); // for native case only
       DebugBreak();
       InterlockedIncrement(&bb);
    
       //after
       L(o);
    
    }
    
    static void D(int o)
    {
       E(o);
    }
    
    static void C(int o)
    {
       int temp = o;
    
       InterlockedIncrement(&aa);
       while (aa < 4)
       {
          ;
       }
    
       if (temp == 1)
       {
          // BP1 - all tasks in C   
          DebugBreak();
          waitFor1 = false;
       }
       else
       {
          while (waitFor1)
          {
             ;
          }
       }
       switch (temp)
       {
       case 1:
          D(o);
          break;
       case 2:
          F(o);
          break;
       case 3:
       case 4:
          I(o);
          break;
       default:
          throw; //fool
          break;
       }
    }
    static void B(int o)
    {
       C(o);
    }
    
    void A(int o)
    {
       B(o);
    }
    int main()
    {
       InitializeCriticalSection(&cs);
    
       task_group tasks;
       task_handle<RunFunc<decltype(A)>> t1(RunFunc<decltype(A)>(A,1));
       tasks.run(t1);
       task_handle<RunFunc<decltype(A)>> t2(RunFunc<decltype(A)>(A,2));
       task2.run(t2);
       task_handle<RunFunc<decltype(A)>> t3(RunFunc<decltype(A)>(A,3));
       task3.run(t3);
       task_handle<RunFunc<decltype(A)>> t4(RunFunc<decltype(A)>(A,4));
       task4.run(t4);
       
       getchar();
       return 1;
    }
    
    Imports System
    Imports System.Threading
    Imports System.Threading.Tasks
    Imports System.Diagnostics
    
    Module S
    
      Sub Main()
    
        pcount = Environment.ProcessorCount
        Console.WriteLine("Proc count = " + pcount.ToString())
        ThreadPool.SetMinThreads(4, -1)
        ThreadPool.SetMaxThreads(4, -1)
    
        t1 = New Task(AddressOf A, 1)
        t2 = New Task(AddressOf A, 2)
        t3 = New Task(AddressOf A, 3)
        t4 = New Task(AddressOf A, 4)
        Console.WriteLine("Starting t1 " + t1.Id.ToString())
        t1.Start()
        Console.WriteLine("Starting t2 " + t2.Id.ToString())
        t2.Start()
        Console.WriteLine("Starting t3 " + t3.Id.ToString())
        t3.Start()
        Console.WriteLine("Starting t4 " + t4.Id.ToString())
        t4.Start()
    
        Console.ReadLine()
      End Sub
      Sub A(ByVal o As Object)
        B(o)
      End Sub
      Sub B(ByVal o As Object)
        C(o)
      End Sub
      Sub C(ByVal o As Object)
    
        Dim temp As Integer = o
    
        Interlocked.Increment(aa)
        While (aa < 4)
        End While
    
        If (temp = 1) Then
          ' BP1 - all tasks in C
          Debugger.Break()
          waitFor1 = False
        Else
          While (waitFor1)
          End While
        End If
        Select Case temp
          Case 1
            D(o)
          Case 2
            F(o)
          Case 3, 4
            I(o)
          Case Else
            Debug.Assert(False, "fool")
        End Select
      End Sub
      Sub D(ByVal o As Object)
        E(o)
      End Sub
      Sub E(ByVal o As Object)
        ' break here at the same time as H and K
        While (bb < 2)
        End While
        'BP2 - 1 in E, 2 in H, 3 in J, 4 in K
        Debugger.Break()
        Interlocked.Increment(bb)
    
        'after
        L(o)
      End Sub
      Sub F(ByVal o As Object)
        G(o)
      End Sub
      Sub G(ByVal o As Object)
        H(o)
      End Sub
      Sub H(ByVal o As Object)
        ' break here at the same time as E and K
        Interlocked.Increment(bb)
        Monitor.Enter(mylock)
        While (bb < 3)
        End While
        Monitor.Exit(mylock)
    
        'after
        L(o)
      End Sub
      Sub I(ByVal o As Object)
        J(o)
      End Sub
      Sub J(ByVal o As Object)
    
        Dim temp2 As Integer = o
    
        Select Case temp2
          Case 3
            t4.Wait()
          Case 4
            K(o)
          Case Else
            Debug.Assert(False, "fool2")
        End Select
      End Sub
      Sub K(ByVal o As Object)
        ' break here at the same time as E and H
        Interlocked.Increment(bb)
        Monitor.Enter(mylock)
        While (bb < 3)
        End While
        Monitor.Exit(mylock)
    
        'after
        L(o)
      End Sub
      Sub L(ByVal oo As Object)
        Dim temp3 As Integer = oo
    
        Select Case temp3
          Case 1
            M(oo)
          Case 2
            N(oo)
          Case 4
            O(oo)
          Case Else
            Debug.Assert(False, "fool3")
        End Select
      End Sub
      Sub M(ByVal o As Object)
        ' breaks here at the same time as N and Q
        Interlocked.Increment(cc)
        While (cc < 3)
        End While
    
        'BP3 - 1 in M, 2 in N, 3 still in J, 4 in O, 5 in Q
        Debugger.Break()
        Interlocked.Increment(cc)
        While (True)
          Thread.Sleep(500) '  for ever
        End While
      End Sub
      Sub N(ByVal o As Object)
        ' breaks here at the same time as M and Q
        Interlocked.Increment(cc)
        While (cc < 4)
        End While
        R(o)
      End Sub
      Sub O(ByVal o As Object)
        Dim t5 As Task = Task.Factory.StartNew(AddressOf P, TaskCreationOptions.AttachedToParent)
        t5.Wait()
        R(o)
      End Sub
      Sub P()
        Console.WriteLine("t5 runs " + Task.CurrentId.ToString())
        Q()
      End Sub
      Sub Q()
        ' breaks here at the same time as N and M
        Interlocked.Increment(cc)
        While (cc < 4)
        End While
        ' task 5 dies here freeing task 4 (its parent)
        Console.WriteLine("t5 dies " + Task.CurrentId.ToString())
        waitFor5 = False
      End Sub
      Sub R(ByVal o As Object)
        If (o = 2) Then
          ' wait for task5 to die
          While waitFor5
          End While
    
          '//spin up all procs
          Dim i As Integer
          For i = 0 To pcount - 4 - 1
    
            Dim t As Task = Task.Factory.StartNew(Sub()
                                                    While True
    
                                                    End While
                                                  End Sub)
            Console.WriteLine("Started task " + t.Id.ToString())
          Next
    
          Task.Factory.StartNew(AddressOf T, i + 1 + 5, TaskCreationOptions.AttachedToParent) ' //scheduled
          Task.Factory.StartNew(AddressOf T, i + 2 + 5, TaskCreationOptions.AttachedToParent) ' //scheduled
          Task.Factory.StartNew(AddressOf T, i + 3 + 5, TaskCreationOptions.AttachedToParent) ' //scheduled
          Task.Factory.StartNew(AddressOf T, i + 4 + 5, TaskCreationOptions.AttachedToParent) ' //scheduled
          Task.Factory.StartNew(AddressOf T, (i + 5 + 5).ToString(), TaskCreationOptions.AttachedToParent) ' //scheduled
    
          '//BP4 - 1 in M, 2 in R, 3 in J, 4 in R, 5 died
          Debugger.Break()
    
        Else
          Debug.Assert(o = 4)
          t3.Wait()
        End If
      End Sub
      Sub T(ByVal o As Object)
        Console.WriteLine("Scheduled run " + Task.CurrentId.ToString())
      End Sub
      Private t1, t2, t3, t4 As Task
      Private aa As Integer = 0
      Private bb As Integer = 0
      Private cc As Integer = 0
      Private waitFor1 As Boolean = True
      Private waitFor5 As Boolean = True
      Private pcount As Integer
      Private mylock As New S2()
    End Module
    
    Public Class S2
    
    End Class
    
  6. Sur le fichier menu, cliquez sur Enregistrer tout.On the File menu, click Save All.

  7. Sur le générer menu, cliquez sur régénérer la Solution.On the Build menu, click Rebuild Solution.

    Notez qu'il y a quatre appels à Debugger.Break (DebugBreak dans l'exemple C++). Vous n'avez donc pas à insérer de points d'arrêt. La simple exécution de l'application entraînera son arrêt dans le débogueur jusqu'à quatre fois.Notice that there are four calls to Debugger.Break (DebugBreak in the C++ sample) Therefore, you do not have to insert breakpoints; just running the application will cause it to break in the debugger up to four times.

Utilisation de la fenêtre Piles parallèles : vue ThreadsUsing the Parallel Stacks Window: Threads View

Dans le menu Déboguer, cliquez sur Démarrer le débogage.On the Debug menu, click Start Debugging. Attendez que le premier point d'arrêt soit atteint.Wait for the first breakpoint to be hit.

Pour afficher la pile des appels d'un thread uniqueTo view the call stack of a single thread

  1. Sur le déboguer menu, pointez sur Windows puis cliquez sur Threads.On the Debug menu, point to Windows and then click Threads. Ancrer le Threads fenêtre en bas de Visual Studio.Dock the Threads window at the bottom of Visual Studio.

  2. Sur le déboguer menu, pointez sur Windows puis cliquez sur pile des appels.On the Debug menu, point to Windows and then click Call Stack. Ancrer le pile des appels fenêtre en bas de Visual Studio.Dock the Call Stack window at the bottom Visual Studio.

  3. Double-cliquez sur un thread dans le Threads fenêtre pour le rendre actuel.Double-click a thread in the Threads window to make it current. Les threads actuels comportent une flèche jaune.Current threads have a yellow arrow. Lorsque vous modifiez le thread actuel, sa pile des appels est affichée dans le pile des appels fenêtre.When you change the current thread, its call stack is displayed in the Call Stack window.

Pour examiner la fenêtre Piles parallèlesTo examine the Parallel Stacks window

  1. Sur le déboguer menu, pointez sur Windows puis cliquez sur piles parallèles.On the Debug menu, point to Windows and then click Parallel Stacks. Assurez-vous que Threads est sélectionné dans la zone dans l’angle supérieur gauche.Make sure that Threads is selected in the box at the upper-left corner.

    À l’aide de la piles parallèles , vous pouvez afficher plusieurs piles d’appels en même temps dans une vue.By using the Parallel Stacks window, you can view multiple call stacks at the same time in one view. L’illustration suivante montre le piles parallèles fenêtre ci-dessus le pile des appels fenêtre.The following illustration shows the Parallel Stacks window above the Call Stack window.

    Threads de vue dans la fenêtre Piles parallèlesThreads view in Parallel Stacks window

    La pile des appels du thread principal s'affiche dans une zone et les piles des appels des quatre autres threads sont regroupées dans une autre zone.The call stack of the Main thread appears in one box and the call stacks for the other four threads are grouped in another box. Quatre threads sont regroupés car leurs frames de pile partagent les mêmes contextes de méthode, ce qui signifie qu'ils se trouvent dans les mêmes méthodes : A, B et C.Four threads are grouped together because their stack frames share the same method contexts; that is, they are in the same methods: A, B, and C. Pour afficher les ID de thread et les noms de threads qui partagent la même zone, pointez sur la zone de l’en-tête (4 Threads).To view the thread IDs and names of the threads that share the same box, hover over the box with the header (4 Threads). Le thread actuel est affiché en gras.The current thread is displayed in bold.

    Info-bulle qui affiche les noms et ID de threadTooltip that shows thread IDs and names

    La flèche jaune indique le frame de pile actif du thread actuel.The yellow arrow indicates the active stack frame of the current thread.

    Vous pouvez définir le niveau de détail à afficher pour les frames de pile (les noms de Module, des Types de paramètres, les noms de paramètres, les valeurs de paramètre, Les numéros de ligne et Offsets d’octet) en cliquant dans le pile des appels fenêtre.You can set how much detail to show for the stack frames (Module Names, Parameter Types, Parameter Names, Parameter Values, Line Numbers and Byte Offsets) by right-clicking in the Call Stack window.

    Une surbrillance bleue autour d'une zone indique que le thread actuel fait partie de cette zone.A blue highlight around a box indicates that the current thread is part of that box. Le thread actuel est également indiqué par le frame de pile en gras dans l'info-bulle.The current thread is also indicated by the bold stack frame in the tooltip. Si vous double-cliquez sur le thread principal dans la fenêtre Threads, vous pouvez observer que la surbrillance bleue de la piles parallèles fenêtre se déplace en conséquence.If you double-click the Main thread in the Threads window, you can observe that the blue highlight in the Parallel Stacks window moves accordingly.

    Mise en surbrillance du thread principal dans la fenêtre Piles parallèlesHighlighted main thread in Parallel Stacks window

Pour continuer l'exécution jusqu'au deuxième point d'arrêtTo resume execution until the second breakpoint

  1. Pour reprendre l’exécution jusqu'à ce que le deuxième point d’arrêt est atteint, sur le déboguer menu, cliquez sur continuer.To resume execution until the second breakpoint is hit, on the Debug menu, click Continue. L’illustration suivante présente l’arborescence des threads au deuxième point d’arrêt.The following illustration shows the thread tree at the second breakpoint.

    Fenêtre Piles parallèles qui présente de nombreuses branchesParallel Stacks window that shows many branches

    Au premier point d'arrêt, les quatre threads sont tous allés de la méthode S.A à S.B et S.C.At the first breakpoint, four threads all went from S.A to S.B to S.C methods. Que les informations sont toujours visibles dans le piles parallèles fenêtre, mais les quatre threads ont depuis progressé plus loin.That information is still visible in the Parallel Stacks window, but the four threads have progressed further. L'un d'entre eux a continué vers S.D, puis S.E.One of them continued to S.D and then S.E. Un autre est allé vers S.F, S.G et S.H.Another continued to S.F, S.G, and S.H. Deux autres ont continué vers S.I et S.J et, de là, l'un d'eux est allé vers S.K et l'autre est parti vers du code externe non-utilisateur.Two others continued to S.I and S.J, and from there one of them went to S.K and the other continued to non-user External Code.

    Vous pouvez pointer sur l’en-tête de zone, par exemple, 1 Thread ou 2 Threads, pour afficher les ID des threads.You can hover over the box header, for example, 1 Thread or 2 Threads, to see the thread IDs of the threads. Vous pouvez pointer sur des frames de pile pour afficher les ID des threads et d'autres détails sur les frames.You can hover over stack frames to see thread IDs plus other frame details. La surbrillance bleue indique le thread actuel et la flèche jaune indique le frame de pile actif du thread actuel.The blue highlight indicates the current thread and the yellow arrow indicates the active stack frame of the current thread.

    L’icône de maillage (lignes d’interweaved) indiquent les frames de pile actifs des threads non actuels.The cloth-threads icon (interweaved lines) indicate the active stack frames of the noncurrent threads. Dans le pile des appels fenêtre, double-cliquez sur S.B pour basculer des frames.In the Call Stack window, double-click S.B to switch frames. Le piles parallèles fenêtre indique le frame de pile actuel du thread actuel à l’aide d’une icône de flèche incurvée verte.The Parallel Stacks window indicates the current stack frame of the current thread by using a green curved arrow icon.

    Dans le Threads fenêtre, basculez entre les threads et remarquez que la vue dans le piles parallèles fenêtre est mise à jour.In the Threads window, switch between threads and observe that the view in the Parallel Stacks window is updated.

    Vous pouvez basculer vers un autre thread, ou vers un autre frame d’un autre thread, à l’aide du menu contextuel de la piles parallèles fenêtre.You can switch to another thread, or to another frame of another thread, by using the shortcut menu in the Parallel Stacks window. Par exemple, cliquez sur S.J, pointez sur basculer vers le Frame, puis cliquez sur une commande.For example, right-click S.J, point to Switch To Frame, and then click a command.

    Chemin d’exécution des piles parallèlesParallel Stacks Path of Execution

    Cliquez sur S.C et pointez sur basculer vers le Frame.Right-click S.C and point to Switch To Frame. L'une des commandes comporte une coche qui indique le frame de pile du thread actuel.One of the commands has a check mark that indicates the stack frame of the current thread. Vous pouvez basculer vers ce frame du même thread (seule la flèche verte se déplace) ou vous pouvez basculer vers l'autre thread (la surbrillance bleue se déplace également).You can switch to that frame of the same thread (just the green arrow will move) or you can switch to the other thread (the blue highlight will also move). L'illustration suivante présente le sous-menu.The following illustration shows the submenu.

    Menu piles avec 2 options sur C alors que J est actifStacks menu with 2 options on C while J is current

    Lorsqu’un contexte de méthode est associé à seulement un frame de pile, l’en-tête de zone affiche 1 Thread et vous pouvez basculer vers lui en double-cliquant.When a method context is associated with just one stack frame, the box header displays 1 Thread and you can switch to it by double-clicking. Si vous double-cliquez sur un contexte de méthode associé à plus d'1 frame, le menu apparaît automatiquement.If you double-click a method context that has more than 1 frame associated with it, then the menu automatically pops up. Lorsque vous pointez sur les contextes de méthode, remarquez le triangle noir à droite.As you hover over the method contexts, notice the black triangle at the right. Le fait de cliquer sur ce triangle affiche également le menu contextuel.Clicking that triangle also displays the shortcut menu.

    Pour les grandes applications qui comportent de nombreux threads, vous pouvez vous concentrer sur un seul sous-ensemble de threads.For large applications that have many threads, you may want to focus on just a subset of threads. Le piles parallèles fenêtre peut afficher des piles d’appels uniquement pour les threads avec indicateur.The Parallel Stacks window can display call stacks only for flagged threads. Pour signaler des threads, utilisez le menu contextuel ou la première cellule d'un thread.To flag threads, use the shortcut menu or the first cell of a thread.

    Dans la barre d’outils, cliquez sur le afficher uniquement avec indicateur bouton en regard de la zone de liste.On the toolbar, click the Show Only Flagged button next to the list box.

    Et les info-bulle de la fenêtre Piles parallèlesParallel Stacks window and tooltip

    Désormais, seul le thread avec indicateur apparaît dans le piles parallèles fenêtre.Now, only the flagged thread shows up in the Parallel Stacks window.

Pour continuer l'exécution jusqu'au troisième point d'arrêtTo resume execution until the third breakpoint

  1. Pour reprendre l’exécution jusqu'à ce que le troisième point d’arrêt est atteint, sur le déboguer menu, cliquez sur continuer.To resume execution until the third breakpoint is hit, on the Debug menu, click Continue.

    Lorsque plusieurs threads se trouvent dans la même méthode mais que cette méthode ne figure pas au début de la pile des appels, la méthode s'affiche dans des zones différentes.When multiple threads are in the same method but the method was not at the beginning of the call stack, the method appears in different boxes. Un exemple au point d'arrêt actuel est S.L, qui possède trois threads et apparaît dans trois zones.An example at the current breakpoint is S.L, which has three threads in it and appears in three boxes. Double-cliquez sur S.L.Double-click S.L.

    Chemin d’exécution dans la fenêtre Piles parallèlesExecution path in Parallel Stacks window

    Remarquez que S.L apparaît en gras dans les deux autres zones afin que vous puissiez voir où il s'affiche.Notice that S.L is bold in the other two boxes so that you can see where else it appears. Si vous souhaitez voir quels frames appeler dans S.L et quels frames, cliquez sur le basculer dans la vue méthode dans la barre d’outils.If you want to see which frames call into S.L and which frames it calls, click the Toggle Method View button on the toolbar. L’illustration suivante montre la vue méthode de la piles parallèles fenêtre.The following illustration shows the method view of The Parallel Stacks window.

    Dans la fenêtre Piles parallèles dans la vue méthodeMethod view in Parallel Stacks window

    Remarquez comment le diagramme a pivoté sur la méthode sélectionnée et l'a positionnée dans sa propre zone au milieu de la vue.Notice how the diagram pivoted on the selected method and positioned it in its own box in the middle of the view. Les appelés et appelants s'affichent en haut et en bas.The callees and callers appear on the top and bottom. Cliquez sur le basculer dans la vue méthode bouton pour quitter ce mode.Click the Toggle Method View button again to leave this mode.

    Le menu contextuel de la piles parallèles fenêtre possède également les éléments suivants autres éléments.The shortcut menu of the Parallel Stacks window also has the following other items.

    • Affichage hexadécimal Active ou désactive les nombres dans les info-bulles entre décimal et hexadécimal.Hexadecimal Display toggles the numbers in the tooltips between decimal and hexadecimal.

    • Paramètres de symboles ouvrir les boîtes de dialogue correspondante.Symbol Settings open the respective dialog boxes.

    • Afficher les Threads dans la Source Active ou désactive l’affichage des marqueurs de thread dans votre code source, qui affiche l’emplacement des threads dans votre code source.Show Threads in Source toggles the display of thread markers in your source code, which shows the location of threads in your source code.

    • Afficher le Code externe affiche tous les frames même s’ils ne sont pas dans le code utilisateur.Show External Code displays all the frames even if they are not in user code. Essayez cet élément pour voir le diagramme se développer pour accueillir les frames supplémentaires (qui peuvent être grisés car vous n’avez pas de symboles pour eux).Try it to see the diagram expand to accommodate the additional frames (which may be dimmed because you do not have symbols for them).

  2. Dans le piles parallèles fenêtre, assurez-vous que le défilement automatique vers le Frame de pile actuel bouton de la barre d’outils est activé.In the Parallel Stacks window, make sure that the Auto Scroll to Current Stack Frame button on the toolbar is on.

    Lorsque vous possédez de grands diagrammes et que vous accédez au point d'arrêt suivant, vous pouvez souhaiter que la vue défile automatiquement vers le frame de pile actif du thread actuel, à savoir le thread qui a atteint en premier le point d'arrêt.When you have large diagrams and you step to the next breakpoint, you may want the view to auto scroll to the active stack frame of the current thread; that is, the thread that hit the breakpoint first.

  3. Avant de continuer, dans le piles parallèles fenêtre, défilez tout à gauche et vers le bas.Before you continue, in the Parallel Stacks window, scroll all the way to the left and all the way down.

Pour continuer l'exécution jusqu'au quatrième point d'arrêtTo resume execution until the fourth breakpoint

  1. Pour reprendre l’exécution jusqu'à ce que la quatrième point d’arrêt est atteint, sur le déboguer menu, cliquez sur continuer.To resume execution until the fourth breakpoint is hit, on the Debug menu, click Continue.

    Remarquez comment la vue défile automatiquement.Notice how the view autoscrolled into place. Basculez des threads dans le Threads frames de pile de fenêtre ou un commutateur dans la pile des appels fenêtre et notez comment la vue défile toujours automatiquement vers le frame approprié.Switch threads in the Threads window or switch stack frames in the Call Stack window and notice how the view always autoscrolls to the correct frame. Désactiver défilement automatique vers le Frame de pile actif option et notez la différence.Turn off Auto Scroll to Current Tool Frame option and view the difference.

    Le vue aérienne est également utile avec les diagrammes de grande taille dans le piles parallèles fenêtre.The Bird's Eye View also helps with large diagrams in the Parallel Stacks window. Par défaut, le vue aérienne sur.By default, the Bird's Eye View is on. Mais vous pouvez l’activer en cliquant sur le bouton situé entre les barres de défilement sur le coin inférieur droit de la fenêtre, comme indiqué dans l’illustration suivante.But you can toggle it by clicking the button between the scroll bars on the lower-right corner of the window, as shown in the following illustration.

    Bird-yeux vue dans la fenêtre Piles parallèlesBird's-eye view in Parallel Stacks window

    Dans la vue aérienne, vous pouvez déplacer le rectangle pour effectuer un panoramique rapide autour du diagramme.In bird's eye view, you can move the rectangle to quickly pan around the diagram.

    Une autre façon de déplacer le diagramme consiste à cliquer dans une zone vide de celui-ci et à le faire glisser où vous le souhaitez.Another way to move the diagram in any direction is to click a blank area of the diagram and drag it where you want it.

    Pour effectuer un zoom avant ou arrière dans le diagramme, appuyez sur CTRL et maintenez cette touche enfoncée pendant que vous déplacez la roulette de la souris.To zoom in and out of the diagram, press and hold CTRL while you move the mouse wheel. Vous pouvez également cliquer sur le bouton Zoom de la barre d'outils, puis utiliser l'outil Zoom.Alternatively, click the Zoom button on the toolbar and then use the Zoom tool.

    Vous pouvez également afficher les piles dans une direction de haut en bas au lieu de bas en haut, en cliquant sur le outils menu, en cliquant sur Options, puis activez ou désactivez l’option sous le dedébogage nœud.You can also view the stacks in a top-down direction instead of bottom-up, by clicking the Tools menu, clicking Options, and then select or clear the option under the Debugging node.

  2. Avant de continuer, sur le déboguer menu, cliquez sur arrêter le débogage pour arrêter l’exécution.Before you continue, on the Debug menu, click Stop Debugging to end execution.

Utilisation de la fenêtre Tâches parallèles et de la vue Tâches de la fenêtre Piles parallèlesUsing the Parallel Tasks Window and the Tasks View of the Parallel Stacks window

Nous vous recommandons d'effectuer les procédures précédentes avant de continuer.We recommended that you complete the earlier procedures before you continue.

Pour redémarrer l'application jusqu'à ce que le premier point d'arrêt soit atteintTo restart the application until the first breakpoint is hit

  1. Sur le déboguer menu, cliquez sur démarrer le débogage et attendez que le premier point d’arrêt soit atteint.On the Debug menu, click Start Debugging and wait for the first breakpoint to be hit.

  2. Sur le déboguer menu, pointez sur Windows puis cliquez sur Threads.On the Debug menu, point to Windows and then click Threads. Ancrer le Threads fenêtre en bas de Visual Studio.Dock the Threads window at the bottom of Visual Studio.

  3. Sur le déboguer menu, pointez sur Windows et cliquez sur pile des appels.On the Debug menu, point to Windows and click Call Stack. Ancrer le pile des appels fenêtre en bas de Visual Studio.Dock the Call Stack window at the bottom Visual Studio.

  4. Double-cliquez sur un thread dans le Threads fenêtre pour le rendre actuel.Double-click a thread in the Threads window to makes it current. Les threads actuels comportent une flèche jaune.Current threads have the yellow arrow. Lorsque vous modifiez le thread actuel, les autres fenêtres sont mises à jour.When you change the current thread, the other windows are updated. Nous allons maintenant examiner les tâches.Next, we will examine tasks.

  5. Sur le déboguer menu, pointez sur Windows, puis cliquez sur tâches.On the Debug menu, point to Windows, and then click Tasks. L’illustration suivante montre le tâches fenêtre.The following illustration shows the Tasks window.

    Quatre en cours d’exécution des tâches dans la fenêtre tâchesFour running tasks in Tasks window

    Pour chaque tâche en cours, vous pouvez lire l’ID, retourné par la propriété de même nom, l’ID et le nom du thread qui l’exécute, ainsi que son emplacement (le fait de pointer dessus affiche une info-bulle qui comporte l’ensemble de la pile des appels).For each running Task, you can read its ID, which is returned by the same-named property, the ID and name of the thread that runs it, its location (hovering over that displays a tooltip that has the whole call stack). En outre, sous la tâche colonne, vous pouvez voir la méthode qui a été passée dans la tâche ; en d’autres termes, le point de départ.Also, under the Task column, you can see the method that was passed into the task; in other words, the starting point.

    Vous pouvez trier toutes les colonnes.You can sort any column. Remarquez le glyphe de tri qui indique la colonne et le sens du tri.Notice the sort glyph that indicates the sort column and direction. Vous pouvez également réorganiser les colonnes en les faisant glisser à gauche ou à droite.You can also reorder the columns by dragging them left or right.

    La flèche jaune indique la tâche actuelle.The yellow arrow indicates the current task. Vous pouvez basculer des tâches en double-cliquant dessus ou en utilisant le menu contextuel.You can switch tasks by double-clicking a task or by using the shortcut menu. Lorsque vous basculez des tâches, le thread sous-jacent devient le thread actuel et les autres fenêtres sont mises à jour.When you switch tasks, the underlying thread becomes current and the other windows are updated.

    Lorsque vous basculez manuellement d'une tâche à une autre, la flèche jaune se déplace, mais une flèche blanche indique toujours la tâche qui a provoqué l'arrêt du débogueur.When you manually switch from one task to another, the yellow arrow moves, but a white arrow still shows the task that caused the debugger to break.

Pour continuer l'exécution jusqu'au deuxième point d'arrêtTo resume execution until the second breakpoint

  1. Pour reprendre l’exécution jusqu'à ce que le deuxième point d’arrêt est atteint, sur le déboguer menu, cliquez sur continuer.To resume execution until the second breakpoint is hit, on the Debug menu, click Continue.

    Auparavant, les état colonne indiquait toutes les tâches comme étant actif, mais maintenant deux tâches sont bloquées.Previously, the Status column showed all tasks as Active, but now two of the tasks are Blocked. Les tâches peuvent être bloquées pour de nombreuses raisons.Tasks can be blocked for many different reasons. Dans le état colonne, pointez sur une tâche en attente pour savoir pourquoi elle est bloquée.In the Status column, hover over a waiting task to learn why it is blocked. Par exemple, dans l’illustration suivante, la tâche 3 attend la tâche 4.For example, in the following illustration, task 3 is waiting on task 4.

    Deux tâches en attente dans la fenêtre tâchesTwo waiting tasks in Tasks window

    La tâche 4, ensuite, attend un gestionnaire possédé par le thread assigné à la tâche 2.Task 4, in turn, is waiting on a monitor owned by the thread assigned to task 2. (Avec le bouton droit de la ligne d’en-tête et choisissez colonnes > affectation de Thread pour afficher la valeur d’affectation de thread pour la tâche 2).(Right-click the header row and choose Columns > Thread Assignment to view the thread assignment value for task 2).

    Tâche en attente et info-bulle dans la fenêtre tâchesWaiting task and tooltip in Tasks window

    Vous pouvez signaler une tâche en cliquant sur l’indicateur dans la première colonne de la tâches fenêtre.You can flag a task by clicking the flag in the first column of the Tasks window.

    Vous pouvez utiliser un indicateur pour effectuer le suivi des tâches entre différents points d’arrêt dans la même session de débogage ou pour filtrer les tâches dont les piles d’appels sont affichées dans le piles parallèles fenêtre.You can use flagging to track tasks between different breakpoints in the same debugging session or to filter for tasks whose call stacks are shown in the Parallel Stacks window.

    Lorsque vous avez utilisé le piles parallèles fenêtre précédemment, vous avez affiché les threads d’application.When you used the Parallel Stacks window earlier, you viewed the application threads. Afficher le piles parallèles fenêtre à nouveau, mais cette fois permet d’afficher les tâches d’application.View the Parallel Stacks window again, but this time view the application tasks. Cela en sélectionnant tâches dans la zone de l’angle supérieur gauche.Do this by selecting Tasks in the box on the upper left. L’illustration suivante présente la vue Tâches.The following illustration shows the Tasks View.

    Tâches de vue dans la fenêtre Piles parallèlesTasks view in Parallel Stacks window

    Les threads qui n’exécutent actuellement pas de tâches n’apparaissent pas dans la vue tâches de la piles parallèles fenêtre.Threads that are not currently executing tasks are not shown in the Tasks View of the Parallel Stacks window. En outre, pour les threads qui exécutent des tâches, certains des frames de pile qui ne sont pas associés aux tâches sont filtrés à partir du haut et bas de la pile.Also, for threads that execute tasks, some of the stack frames that are not relevant to tasks are filtered from the top and bottom of the stack.

    Afficher le tâches fenêtre à nouveau.View the Tasks window again. Cliquez avec le bouton droit sur un en-tête de colonne pour afficher un menu contextuel pour cette colonne.Right-click any column header to see a shortcut menu for the column.

    Vous pouvez utiliser le menu contextuel pour ajouter ou supprimer des colonnes.You can use the shortcut menu to add or remove columns. Par exemple, la colonne AppDomain n'est pas sélectionnée. Elle ne s'affiche donc pas dans la liste.For example, the AppDomain column is not selected; therefore, it is not displayed in the list. Cliquez sur Parent.Click Parent. Le Parent colonne s’affiche sans valeur pour chacune des quatre tâches.The Parent column appears without values for any of the four tasks.

Pour continuer l'exécution jusqu'au troisième point d'arrêtTo resume execution until the third breakpoint

  1. Pour reprendre l’exécution jusqu'à ce que le troisième point d’arrêt est atteint, sur le déboguer menu, cliquez sur continuer.To resume execution until the third breakpoint is hit, on the Debug menu, click Continue.

    Une nouvelle tâche, la tâche 5, est en cours d’exécution et la tâche 4 est maintenant en attente.A new task, task 5, is now running and task 4 is now waiting. Vous pouvez voir pourquoi en pointant sur la tâche en attente dans le état fenêtre.You can see why by hovering over the waiting task in the Status window. Dans le Parent colonne, notez que la tâche 4 est le parent de la tâche 5.In the Parent column, notice that task 4 is the parent of task 5.

    Pour mieux visualiser la relation parent-enfant, avec le bouton droit de la ligne d’en-tête de colonne, puis cliquez sur Vue Parent enfant.To better visualize the parent-child relationship, right-click the column header row and then click Parent Child View. L'illustration suivante doit apparaître.You should see the following illustration.

    Parent-vue enfant dans la fenêtre tâchesParent-child view in Tasks window

    Remarquez que la tâche 4 et la tâche 5 sont exécutent sur le même thread (afficher les affectation de Thread colonne si elle est masquée).Notice that task 4 and task 5 are running on the same thread (show the Thread Assignment column if it is hidden). Ces informations s’affichent pas dans le Threads fenêtre ; leur affichage ici constitue un autre avantage de la tâches fenêtre.This information is not displayed in the Threads window; seeing it here is another benefit of the Tasks window. Pour confirmer ceci, affichez la piles parallèles fenêtre.To confirm this, view the Parallel Stacks window. Assurez-vous que vous visualisez tâches.Make sure that you are viewing Tasks. Localisez les tâches 4 et 5 en double-cliquant dessus dans le tâches fenêtre.Locate tasks 4 and 5 by double-clicking them in the Tasks window. Dans ce cas, la surbrillance bleue la piles parallèles fenêtre est mise à jour.When you do, the blue highlight in the Parallel Stacks window is updated. Vous pouvez également localiser les tâches 4 et 5 en analysant les info-bulles de la piles parallèles fenêtre.You can also locate tasks 4 and 5 by scanning the tooltips on the Parallel Stacks window.

    Vue dans la fenêtre Piles parallèles de tâchesTask view in Parallel Stacks window

    Dans le piles parallèles fenêtre, cliquez sur S.P, puis cliquez sur atteindre le Thread.In the Parallel Stacks window, right-click S.P, and then click Go To Thread. La fenêtre passe à la vue Threads et le frame correspondant s'affiche.The window switches to Threads View and the corresponding frame is in view. Vous pouvez voir les deux tâches sur le même thread.You can see both tasks on the same thread.

    Mise en surbrillance de thread dans la vue threadsHighlighted thread in threads view

    Il s’agit d’un autre avantage de la vue tâches de la piles parallèles fenêtre, par rapport à la Threads fenêtre.This is another benefit of the Tasks View in the Parallel Stacks window, compared to the Threads window.

Pour continuer l'exécution jusqu'au quatrième point d'arrêtTo resume execution until the fourth breakpoint

  1. Pour reprendre l’exécution jusqu'à ce que le troisième point d’arrêt est atteint, sur le déboguer menu, cliquez sur continuer.To resume execution until the third breakpoint is hit, on the Debug menu, click Continue. Cliquez sur le ID en-tête de colonne pour trier par ID.Click the ID column header to sort by ID. L'illustration suivante doit apparaître.You should see the following illustration.

    Quatre états de tâche dans la fenêtre Piles parallèlesFour task states in Parallel Stacks window

    Étant donné que la tâche 5 est terminée, elle n’est plus affichée.Because task 5 has completed, it is no longer displayed. Une fois l’étape si qui n’est pas le cas sur votre ordinateur et que le blocage n’est pas affiché, en appuyant sur F11.If that is not the case on your computer and the deadlock is not shown, step one time by pressing F11.

    Tâches 3 et 4 sont attendent maintenant l’autre et sont bloquées.Task 3 and task 4 are now waiting on each other and are blocked. Il y a également 5 nouvelles tâches qui sont des enfants de la tâche 2 et qui sont maintenant planifiées.There are also 5 new tasks that are children of task 2 and are now scheduled. Les tâches planifiées sont des tâches qui ont été démarrées dans le code mais qui n’ont pas encore été exécutées.Scheduled tasks are tasks that have been started in code but have not run yet. Par conséquent, leur emplacement et affectation de Thread colonnes sont vides.Therefore, their Location and Thread Assignment columns are empty.

    Afficher le piles parallèles fenêtre à nouveau.View the Parallel Stacks window again. L'en-tête de chaque zone comporte une info-bulle qui affiche les ID et noms de thread.The header of each box has a tooltip that shows the thread IDs and names. Basculez en vue tâches dans le piles parallèles fenêtre.Switch to Tasks View in the Parallel Stacks window. Pointez sur un en-tête pour afficher l’ID et le nom de la tâche, ainsi que son état, comme indiqué dans l’illustration suivante.Hover over a header to see the task ID and name, and the status of the task, as shown in the following illustration.

    Info-bulle de l’en-tête dans la fenêtre Piles parallèlesHeader tooltip in Parallel Stacks window

    Vous pouvez regrouper les tâches par colonne.You can group the tasks by column. Dans le tâches fenêtre, avec le bouton droit le état en-tête de colonne, puis cliquez sur Grouper par état.In the Tasks window, right-click the Status column header and then click Group by Status. L’illustration suivante montre le tâches fenêtre regroupés par état.The following illustration shows the Tasks window grouped by status.

    Des tâches dans la fenêtre tâches regroupéesGrouped tasks in Tasks window

    Vous pouvez également regrouper les tâches en fonction d'une autre colonne.You can also group by any other column. Cela vous permet de vous concentrer sur un sous-ensemble de tâches.By grouping tasks, you can focus on a subset of tasks. Chaque groupe réductible comporte un certain nombre des éléments regroupés ensemble.Each collapsible group has a count of the items that are grouped together.

    La dernière fonctionnalité de la tâches fenêtre à examiner est le menu contextuel qui s’affiche lorsque vous cliquez sur une tâche.The last feature of the Tasks window to examine is the shortcut menu that is displayed when you right-click a task.

    Ce menu contextuel contient différentes commandes en fonction de l’état de la tâche.The shortcut menu displays different commands, depending on the status of the task. Ces commandes sont copie, sélectionner tout, affichage hexadécimal, basculer vers la tâche, figer affecté Thread, figer tous les Threads, mais il, et libérer le Thread assigné, et indicateur.The commands may include Copy, Select All, Hexadecimal Display, Switch to Task, Freeze Assigned Thread, Freeze All Threads But This, and Thaw Assigned Thread, and Flag.

    Vous pouvez verrouiller le thread sous-jacent d’une ou plusieurs tâches, ainsi que verrouiller tous les threads sauf celui qui est assigné.You can freeze the underlying thread of a task, or tasks, or you can freeze all threads except the assigned one. Un thread verrouillé est représenté dans le tâches fenêtre telle qu’elle est dans le Threads fenêtre, en un bleu suspendre icône.A frozen thread is represented in the Tasks window as it is in the Threads window, by a blue pause icon.

RécapitulatifSummary

Cette procédure pas à pas démontré la tâches parallèles et piles parallèles fenêtres du débogueur.This walkthrough demonstrated the Parallel Tasks and Parallel Stacks debugger windows. Vous pouvez utiliser ces fenêtres sur de véritables projets qui utilisent du code multithread.Use these windows on real projects that use multithreaded code. Vous pouvez examiner le code parallèle rédigé en C++, C# ou Visual Basic.You can examine parallel code written in C++, C#, or Visual Basic.

Voir aussiSee Also

Débogage d’Applications multithread Debugging Multithreaded Applications
Principes de base du débogueur Debugger Basics
Débogage du code managé Debugging Managed Code
Programmation parallèle Parallel Programming
Runtime d’accès concurrentiel Concurrency Runtime
À l’aide de la fenêtre Piles parallèles Using the Parallel Stacks Window
Utilisation de la fenêtre TâchesUsing the Tasks Window