Comment utiliser le travailleur d'arrière-plan WPF

Question

Dans mon application, je dois effectuer une série d'étapes d'initialisation, qui prennent 7 à 8 secondes, pendant lesquelles l'interface utilisateur ne répond plus. Pour résoudre ce problème, j'effectue l'initialisation dans un thread séparé :

public void Initialization()
{
    Thread initThread = new Thread(new ThreadStart(InitializationThread));
    initThread.Start();
}

public void InitializationThread()
{
    outputMessage("Initializing...");
    //DO INITIALIZATION
    outputMessage("Initialization Complete");
}

J'ai lu quelques articles sur le BackgroundWorker et comment il devrait me permettre de garder mon application réactive sans avoir à écrire un thread pour effectuer de longues tâches, mais je n'ai pas réussi à le mettre en œuvre. BackgroundWorker ?

Answer 1

1. Ajouter en utilisant

   using System.ComponentModel;

2. Déclarer Travailleur de fond :

   private readonly BackgroundWorker worker = new BackgroundWorker();

3. S'abonner aux événements :

   worker.DoWork += worker_DoWork; worker.RunWorkerCompleted += worker_RunWorkerCompleted;

4. Mettre en œuvre deux méthodes :

   private void worker_DoWork(object sender, DoWorkEventArgs e) { // run all background tasks here }

   private void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { //update ui once worker complete his work }

5. Exécutez le travailleur de manière asynchrone chaque fois que vous en avez besoin.

   worker.RunWorkerAsync();

6. Suivi des progrès (facultatif, mais souvent utile)

   a) s'abonner à ProgressChanged et utiliser ReportProgress(Int32) en DoWork

   b) fixer worker.WorkerReportsProgress = true; (crédits à @zagy)

Answer 2

Vous pouvez également envisager d'utiliser Task au lieu des travailleurs de fond.

La façon la plus simple de le faire est dans votre exemple est Task.Run(InitializationThread); .

L'utilisation de tâches au lieu de travailleurs d'arrière-plan présente plusieurs avantages. Par exemple, les nouvelles fonctionnalités async/await de .net 4.5 utilisent Task pour l'enfilage. Voici de la documentation sur Task https://docs.microsoft.com/en-us/dotnet/api/system.threading.tasks.task

Answer 3

En plus de ce qu'Andrew Orsich a dit, vous voudrez peut-être lire quelques exemples à ce sujet.

Voici un exemple de code utilisant un travailleur en arrière-plan et une barre de progression.

http://devtoolshed.com/content/c-download-file-progress-bar

et voici un petit tutoriel

http://www.dotnetperls.com/backgroundworker

et il y a un lien pour un autre exemple de progressbar+backgroundworker à la fin du tutoriel.

Answer 4

J'ai trouvé ceci ( WPF Multithreading : Utiliser le BackgroundWorker et signaler la progression à l'interface utilisateur. lien ) pour contenir le reste des détails qui manquent dans la réponse de @Andrew.

La seule chose que j'ai trouvée très utile, c'est que le fil de travail ne pouvait pas accéder aux contrôles de la fenêtre principale (dans sa propre méthode), mais que cela était possible en utilisant un délégué dans le gestionnaire d'événements de la fenêtre principale.

worker.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs args)
{
    pd.Close();
    // Get a result from the asynchronous worker
    T t = (t)args.Result
    this.ExampleControl.Text = t.BlaBla;
};

Answer 5

Essayez ce lien Classe BackgroundWorker dans MSDN qui contient un exemple d'utilisation.