Framework 2.0 : Présentation du composant BackgroundWorker (VB.Net)

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 WithEvents bgwCode As System.ComponentModel.BackgroundWorker

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 System.ComponentModel.BackgroundWorker

bgwCode.WorkerReportsProgress = True
bgwCode.WorkerSupportsCancellation = True

AddHandler bgwCode.DoWork, AddressOf bgwCode_DoWork
AddHandler bgwCode.RunWorkerCompleted, AddressOf bgwCode_RunWorkerCompleted
AddHandler bgwCode.ProgressChanged, AddressOf 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 Sub btnStartCancel_Click( _
    ByVal sender As System.Object, _
    ByVal e As System.EventArgs) _
    Handles btnStartCancel.Click
    
    If btnStartCancel.Text.Equals("Démarrer") Then
        lblResult.Text = "Traitement en cours..."
        btnStartCancel.Text = "Annuler"
        nudNbLoop.Enabled = False
        bgwDesign.RunWorkerAsync(CInt(nudNbLoop.Value))
    Else
        ...
    End If
End Sub

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 Sub bgwDesign_DoWork( _
    ByVal sender As System.Object, _
    ByVal e As System.ComponentModel.DoWorkEventArgs) _
    Handles bgwDesign.DoWork

    Dim worker As BackgroundWorker = CType(sender, BackgroundWorker)
    e.Result = Treatment(CInt(e.Argument), CInt(e.Argument), worker, e)
End Sub

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 Function Treatment( _
    ByVal nb As Integer, _ 
    ByVal max As Integer, _
    ByVal worker As BackgroundWorker, _
    ByVal e As DoWorkEventArgs) As Long
    
    Dim result As Long = 0

    If worker.CancellationPending Then
        e.Cancel = True
    Else
        Dim pourcent As Integer = CInt(((CDec(max) - CDec(nb)) / CDec(max) * 100))
        worker.ReportProgress(pourcent)
        If nb <= 1 Then
            result = 1
        Else
            System.Threading.Thread.Sleep(100)
            result = Treatment(nb - 1, max, worker, e) + 1
        End If
    End If
    
    Return result
End Function

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 Sub bgwDesign_ProgressChanged( _
    ByVal sender As Object, _
    ByVal e As ProgressChangedEventArgs) _
    Handles bgwDesign.ProgressChanged
    
    pgbState.Value = e.ProgressPercentage
End Sub

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 Sub btnStartCancel_Click( _
    ByVal sender As Object, _
    ByVal e As EventArgs) _
    Handles btnStartCancel.Click
    
    If btnStartCancel.Text.Equals("Démarrer") Then
        ...
    Else
        bgwDesign.CancelAsync()
        btnStartCancel.Text = "Démarrer"
        pgbState.Value = 0
        nudNbLoop.Enabled = True
    End If
End Sub

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 Sub bgwDesign_RunWorkerCompleted( _
    ByVal sender As Object, _
    ByVal e As RunWorkerCompletedEventArgs) _
    Handles bgwDesign.RunWorkerCompleted

    If Not (e.Error Is Nothing) Then
        lblResult.Text = "Une erreur est survenue ! Détail : " + e.Error.Message
    ElseIf e.Cancelled Then
        lblResult.Text = "Opération annulée !"
    Else
        lblResult.Text = "Opération terminée ! Résultat : " + e.Result.ToString
    End If

    btnStartCancel.Text = "Démarrer"
    nudNbLoop.Enabled = True
    pgbState.Value = 0
End Sub