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 inactif. 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 que 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 temps d’inactivité en fractionnant un long processus en plusieurs 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 explique deux façons d’effectuer un traitement inactif 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 OnIdle fonction membre d’entre CWinThread les messages. Une application peut traiter les messages dans ce temps inactif en remplaçant la OnIdle fonction.

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 pour effectuer un traitement inactif dans une application implique l’incorporation d’une boucle de message dans l’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 qu’une telle boucle dans une application développée avec MFC doit exécuter plusieurs des mêmes fonctions que la boucle de message principale. Le fragment de code suivant illustre l’écriture d’une boucle de message 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, effectue des boucles tant qu’il y a un traitement inactif à effectuer. Dans cette boucle, une boucle imbriquée appelle PeekMessageà plusieurs reprises . Tant que cet appel retourne une valeur différente de zéro, la boucle appelle CWinThread::PumpMessage pour effectuer la traduction et la répartition normales des messages. Bien qu’il PumpMessage ne soit pas documenté, vous pouvez examiner son code source dans le fichier ThrdCore.Cpp dans le répertoire \atlmfc\src\mfc de votre installation Visual C++.

Une fois la boucle interne terminée, la boucle externe effectue un traitement inactif avec un ou plusieurs appels à OnIdle. Le premier appel est destiné aux fins de MFC. Vous pouvez effectuer des appels supplémentaires pour OnIdle 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