Traitement des boucles inactives

De nombreuses applications effectuent un traitement long « en arrière-plan ». Parfois, les considérations relatives aux performances dictent l’utilisation de multithreading pour ce travail. Les threads impliquent une surcharge de développement supplémentaire. Ils ne sont donc pas recommandés pour les tâches simples telles que le travail au moment d’inactivité que fait MFC dans la fonction OnIdle . Cet article se concentre sur le traitement des temps d'inactivité. Pour plus d’informations sur le multithreading, consultez rubriques sur le multithreading.

Certains types de traitement en arrière-plan sont correctement effectués pendant les intervalles où l'utilisateur n'interagit pas avec l'application. Dans une application développée pour le système d'exploitation Microsoft Windows, une application peut effectuer un traitement en période d'inactivité en divisant un processus long en de nombreux petits fragments. Après avoir traité chaque fragment, l’application génère un contrôle d’exécution sur Windows à l’aide d’une boucle PeekMessage .

Cet article décrit les deux modes de traitement des temps d'inactivité pouvant être exécutés dans votre application :

• Utilisation de PeekMessage dans la boucle de message principale de MFC.

• Incorporation d’une autre boucle PeekMessage ailleurs dans l’application.

PeekMessage dans la boucle de message MFC

Dans une application développée avec MFC, la boucle de message principale de la CWinThread classe contient une boucle de message qui appelle l’API PeekMessage Win32. Cette boucle appelle également la fonction membre OnIdle de CWinThread entre les messages. Une application peut traiter les messages dans cette durée d'inactivité en remplaçant la fonction OnIdle.

Remarque

Run, OnIdleet certaines autres fonctions membres sont désormais membres de classe CWinThread plutôt que de classe CWinApp. CWinApp est dérivé de CWinThread.

Pour plus d’informations sur l’exécution du traitement inactif, consultez OnIdle dans la référence MFC.

PeekMessage Elsewhere in Your Application

Une autre méthode de traiter les temps d'inactivité dans une application implique l'incorporation d'une boucle de messages dans une de vos fonctions. Cette boucle de message est très similaire à la boucle de message principale de MFC, trouvée dans CWinThread ::Run. Cela signifie que cette boucle dans une application développée avec MFC doit exécuter plusieurs des fonctions identiques à la boucle de messages principale. Le fragment de code suivant montre comment écrire une boucle de messages compatible avec MFC :

BOOL bDoingBackgroundProcessing = TRUE;
while (bDoingBackgroundProcessing)
{
   MSG msg;
   while (::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
   {
      if (!AfxGetApp()->PumpMessage())
      {
         bDoingBackgroundProcessing = FALSE;
         ::PostQuitMessage(0);
         break;
      }
   }
   // let MFC do its idle processing
   LONG lIdle = 0;
   while (AfxGetApp()->OnIdle(lIdle++))
      ;
   // Perform some background processing here 
   // using another call to OnIdle
}

Ce code, incorporé dans une fonction, tourne en boucle tant que du temps d'inactivité est à traiter. Dans cette boucle, une boucle imbriquée appelle PeekMessageà plusieurs reprises . Comme cet appel retourne une valeur différente de zéro, la boucle appelle CWinThread::PumpMessage pour effectuer la conversion et la distribution des messages normaux. Bien que PumpMessage soit non documenté, vous pouvez examiner son code source dans le fichier ThrdCore.Cpp du répertoire \atlmfc\src\mfc du programme d'installation de Visual C++.

Une fois que la boucle interne se termine, la boucle externe effectue le traitement des temps d'inactivité avec un ou plusieurs appels à OnIdle. Le premier appel est destiné aux objectifs de MFC. Vous pouvez effectuer des appels supplémentaires à OnIdle pour effectuer votre propre travail en arrière-plan.

Pour plus d’informations sur l’exécution du traitement inactif, consultez OnIdle dans la référence de la bibliothèque MFC.

Voir aussi

Rubriques MFC générales