Framework 2.0 : Présentation du composant BackgroundWorker (C#)

Pour créer un BackgroundWorker à l'aide du designer de Visual Studio, rien de plus simple : il nous suffit de faire glisser depuis l'onglet Components de la Toolbox le composant BackgroundWorker sur notre formulaire.

Nous pouvons ensuite visualiser ses propriétés et les modifier.

J'ai ainsi renommé mon BackgroundWorker bgwDesign et passé ses propriétés WorkerReportsProgress et WorkerSupportsCancellation à true.

La propriété WorkerReportsProgress donne à notre BackgroundWorker la possibilité de nous informer ou non de son état d'avancement.

La propriété WorkerSupportsCancellation nous permet, quant à elle, d'autoriser ou non l'annulation de la tâche en cours du BackgroundWorker.

Nous abonnons ensuite notre BackgroundWorker aux événements qui nous intéressent :

• DoWork : C'est cet événement qui se déclenche lorsque nous faisons appel au BackgroundWorker ;
• ProgressChanged : Cet événement, si la propriété WorkerReportsProgress est activée, se déclenche lorsque nous voulons indiquer que l'état d'avancement du BackgroundWorker change ;
• RunWorkerCompleted : Une fois le traitement du BackgroundWorker terminé cet événement est déclenché.

Pour créer notre BackgroundWorker directement dans le code, il faut dans un premier temps le déclarer. Je l'ai appelé bgwCode.

private System.ComponentModel.BackgroundWorker bgwCode;

Nous devons ensuite l'instancier, initialiser ses propriétés (RunWorkerCompleted et ProgressChanged) et l'abonner aux différents événements (DoWork, RunWorkerCompleted et ProgressChanged) dont je vous ai parlé précédemment.

bgwCode = new BackgroundWorker();

bgwCode.WorkerReportsProgress = true;
bgwCode.WorkerSupportsCancellation = true;

bgwCode.DoWork += new DoWorkEventHandler(bgwCode_DoWork);
bgwCode.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bgwCode_RunWorkerCompleted);
bgwCode.ProgressChanged += new ProgressChangedEventHandler(bgwCode_ProgressChanged);

Nous pouvons donc pu constater que la création de notre BackgroundWorker s'est passé très simplement dans les deux cas. Voyons maintenant comment l'utiliser.

Nous avons donc :

• un NumericUpDown nudNbLoop permettant de choisir le nombre de tours de boucle ;
• un Button btnStartCancel permettant de démarrer ou d'annuler le traitement ;
• un Label lblResult permettant d'afficher le résultat ;
• une ProgressBar pgbState permettant de visualiser l'état d'avancement du traitement.

Pour lancer le traitement, il nous suffit de cliquer sur le bouton btnStartCancel. C'est dans l'événement clic de ce bouton que nous appelons la méthode RunWorkerAsync du BackgroundWorker. Celle-ci prépare le nouveau thread. Une fois le nouveau thread démarré, l'événement DoWork est déclenché ce qui permet au traitement en arrière-plan de s'exécuter de manière asynchrone. Nous passons en paramètre à la méthode RunWorkerAsync le nombre de tours de boucle choisi par l'utilisateur au travers de nudNbLoop.

private void btnStartCancel_Click(object sender, EventArgs e)
{
    if (btnStartCancel.Text.Equals("Démarrer"))
    {
        lblResult.Text = "Traitement en cours...";
        btnStartCancel.Text = "Annuler";
        nudNbLoop.Enabled = false;
        bgwDesign.RunWorkerAsync((int)nudNbLoop.Value);
    }
    else
    {
        ...
    }
}

C'est dans l'événement DoWork que nous appelons la méthode Treatment qui, comme son nom l'indique réalise le traitement. Pour cela nous récupérons tout d'abord l'objet BackgroundWorker qui a déclenché l'événement et qui nous est fourni par l'objet sender. Nous passons ensuite le nombre de tours de boucle choisi par l'utilisateur grâce à la propriété Argument des DoWorkEventArgs.

private void bgwDesign_DoWork(object sender, DoWorkEventArgs e)
{
    BackgroundWorker worker = sender as BackgroundWorker;

    e.Result = Treatment((int)e.Argument, (int)e.Argument, worker, e);
}

Pour le traitement je me suis basé sur une méthode récursive. Néanmoins, une méthode avec une simple boucle for n'aurait rien changé au principe. Les points importants de cette méthode sont les suivants :

• vérifier grâce à la propriété CancellationPending du BackgroundWorker si aucune demande d'annulation n'a été faite. Si c'est le cas alors positionner la propriété Cancel du DoWorkEventArgs à true ce qui aura pour résultat de stopper l'exécution du BackgroundWorker ;
• faire le traitement : ici je fais un Sleep de 100 millisecondes et je retourne le nombre de boucles effectuées ;
• appeler la méthode ReportProgress du BackgroundWorker et lui passer en paramètre le pourcentage d'avancement. Cette méthode déclenche alors l'événement ProgressChanged. Il est à noter que la logique de calcul du pourcentage d'avancement doit être entièrement gérée par le développeur en fonction de l'architecture du traitement.

private long Treatment(int nb, int max, BackgroundWorker worker, DoWorkEventArgs e)
{
    long result = 0;

    if (worker.CancellationPending)
    {
        e.Cancel = true;
    }
    else
    {
        int pourcent = (int)(((double)max - (double)nb) / (double)max * 100);
        worker.ReportProgress(pourcent);

        if (nb <= 1)
        {
            result = 1;
        }
        else
        {
            System.Threading.Thread.Sleep(100); 
            result = Treatment(nb - 1, max, worker, e) + 1;
        }
    }

    return result;
}

L'événement ProgressChanged s'exécutant dans le même thread que l'UI, cela nous permet donc d'accéder à ses contrôles. Dans le cas présent, j'utilise une ProgressBar pour visualiser l'évolution du traitement. Nous pouvons donc utiliser la propriété ProgressPercentage du ProgressChangedEventArgs pour modifier la valeur de la ProgressBar.

private void bgwDesign_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    this.progressBar1.Value = e.ProgressPercentage;
}

Outre le fait de faire remonter l'état d'avancement à l'utilisateur, celui-ci peut choisir d'annuler le traitement.

Pour annuler le traitement, il nous suffit de cliquer sur le bouton btnStartCancel. C'est dans l'événement clic de ce bouton que nous appelons la méthode CancelAsync du BackgroundWorker. Celle-ci demande l'arrêt du traitement en cours et positionne la propriété CancellationPending du BackgroundWorker à true. C'est ensuite à la logique interne du traitement de vérifier régulièrement l'état de cette propriété.

private void btnStartCancel_Click(object sender, EventArgs e)
{
    if (btnStartCancel.Text.Equals("Démarrer"))
    {
        ...
    }
    else
    {
        bgwDesign.CancelAsync();
        btnStartCancel.Text = "Démarrer";
        pgbState.Value = 0;
        nudNbLoop.Enabled = true;
    }
}

Pour finir, il ne nous reste plus qu'à afficher le résultat.
Il peut y avoir plusieurs types de résultats :

• il y a eu une erreur pendant le traitement. Dans ce cas la propriété Error du RunWorkerCompletedEventArgs est différente de null ;
• le traitement a été annulé. Dans ce cas la propriété Canceled du RunWorkerCompletedEventArgs est à true ;
• le traitement s'est déroulé normalement. Nous pouvons afficher le résultat qui se trouve dans la propriété Result du RunWorkerCompletedEventArgs.

private void bgwDesign_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    if (e.Error != null)
    {
        lblResult.Text = "Une erreur est survenue ! Détail : " + e.Error.Message;
    }
    else if (e.Cancelled)
    {
        lblResult.Text = "Opération annulée !";
    }
    else
    {
        lblResult.Text = "Opération terminée ! Résultat : " + e.Result.ToString();
    }
    
    btnStartCancel.Text = "Démarrer";
    nudNbLoop.Enabled = true;
    pgbState.Value = 0;
}