Vue d'ensemble du composant BackgroundWorker

Article
08/21/2008

Mise à jour : novembre 2007

Il existe beaucoup d'opérations couramment exécutées dont le délai d'exécution est long. Par exemple :

Téléchargements d'images
Appels de service Web
Téléchargements et télétransmissions de fichiers (y compris pour les applications d'égal à égal)
Calculs locaux complexes
Transactions de base de données
Accès au disque local, compte tenu de sa vitesse lente par rapport à l'accès mémoire

Les opérations comme celles-ci peuvent entraîner le blocage votre interface utilisateur pendant leur exécution. Lorsque vous souhaitez une interface utilisateur réactive et que vous devez supporter de longs délais associés à de telles opérations, le composant BackgroundWorker fournit une solution commode.

Le composant BackgroundWorker vous donne la possibilité d'exécuter les opérations longues de façon asynchrone (« en arrière-plan »), sur un thread différent du thread d'interface utilisateur principal de votre application. Pour utiliser un BackgroundWorker, vous lui indiquez simplement quelle méthode de travail de longue durée exécuter en arrière-plan, puis, vous appelez la méthode RunWorkerAsync. Votre thread d'appel continue de s'exécuter normalement pendant que la méthode de travail s'exécute de façon asynchrone. Lorsque l'exécution de la méthode est terminée, le BackgroundWorker alerte le thread d'appel en déclenchant l'événement RunWorkerCompleted, lequel contient éventuellement les résultats de l'opération.

Le composant BackgroundWorker est disponible dans la Boîte à outils, sous l'onglet Composants. Pour ajouter un BackgroundWorker à votre formulaire, faites glisser le composant BackgroundWorker sur votre formulaire. Il apparaît dans la barre d'état des composants, et ses propriétés apparaissent dans la fenêtre Propriétés.

Pour démarrer votre opération asynchrone, utilisez la méthode RunWorkerAsync. RunWorkerAsync prend un paramètre object facultatif qui peut être utilisé pour passer des arguments à votre méthode de travail. La classe BackgroundWorker expose l'événement DoWork, auquel votre thread de travail est attaché à travers un gestionnaire d'événements DoWork.

Le gestionnaire d'événements DoWork prend un paramètre DoWorkEventArgs, qui a une propriété Argument. Cette propriété reçoit le paramètre de RunWorkerAsync et peut être passée à votre méthode de travail qui sera appelée dans le gestionnaire d'événements DoWork. L'exemple suivant montre comment assigner un résultat d'une méthode de travail appelée ComputeFibonacci. Il fait partie d'un plus grand exemple que vous pouvez trouver à l'emplacement suivant : Comment : implémenter un formulaire qui utilise une opération d'arrière-plan.

' This event handler is where the actual work is done.
Private Sub backgroundWorker1_DoWork( _
ByVal sender As Object, _
ByVal e As DoWorkEventArgs) _
Handles backgroundWorker1.DoWork

    ' Get the BackgroundWorker object that raised this event.
    Dim worker As BackgroundWorker = _
        CType(sender, BackgroundWorker)

    ' Assign the result of the computation
    ' to the Result property of the DoWorkEventArgs
    ' object. This is will be available to the 
    ' RunWorkerCompleted eventhandler.
    e.Result = ComputeFibonacci(e.Argument, worker, e)
End Sub 'backgroundWorker1_DoWork

// This event handler is where the actual,
// potentially time-consuming work is done.
private void backgroundWorker1_DoWork(object sender, 
    DoWorkEventArgs e)
{   
    // Get the BackgroundWorker that raised this event.
    BackgroundWorker worker = sender as BackgroundWorker;

    // Assign the result of the computation
    // to the Result property of the DoWorkEventArgs
    // object. This is will be available to the 
    // RunWorkerCompleted eventhandler.
    e.Result = ComputeFibonacci((int)e.Argument, worker, e);
}

// This event handler is where the actual,
// potentially time-consuming work is done.
void backgroundWorker1_DoWork( Object^ sender, DoWorkEventArgs^ e )
{
   // Get the BackgroundWorker that raised this event.
   BackgroundWorker^ worker = dynamic_cast<BackgroundWorker^>(sender);

   // Assign the result of the computation
   // to the Result property of the DoWorkEventArgs
   // object. This is will be available to the 
   // RunWorkerCompleted eventhandler.
   e->Result = ComputeFibonacci( safe_cast<Int32>(e->Argument), worker, e );
}

// This event handler is where the actual,
// potentially time-consuming work is done.
private void backgroundWorker1_DoWork(Object sender, DoWorkEventArgs e)
{
    // Get the BackgroundWorker that raised this event.
    BackgroundWorker worker = (BackgroundWorker)sender;

    // Assign the result of the computation
    // to the Result property of the DoWorkEventArgs
    // object. This is will be available to the 
    // RunWorkerCompleted eventhandler.
    e.set_Result(new Long(ComputeFibonacci(System.Convert.ToInt32
        (e.get_Argument()), worker, e)));
    //e.Result = ComputeFibonacci((int)e.Argument, worker, e); 
} //backgroundWorker1_DoWork

Pour plus d'informations sur l'utilisation des gestionnaires d'événements, consultez Événements et délégués.

Attention :
Lorsque vous utilisez le multithreading, vous vous exposez potentiellement à des bogues très sérieux et complexes. Consultez Méthodes conseillées pour le threading managé avant d'implémenter une solution utilisant le multithreading.

Pour plus d'informations sur l'utilisation de la classe BackgroundWorker, consultez Comment : exécuter une opération en arrière-plan.

Partager via

Vue d'ensemble du composant BackgroundWorker

Voir aussi

Tâches

Autres ressources

Ressources supplémentaires