Passage d'une méthode à un backgroundworker dowork

Dans le code ci-dessous, il est un moyen pour, au lieu de toujours s'abonner à la updateWorker_DoWork méthode, passer d'une méthode comme ceci

public void GetUpdates(SomeObject blah)
{
    //...
    updateWorker.DoWork += new DoWorkEventHandler(blah);
    //...
}


public void GetUpdates()
{
    //Set up worker
    updateWorker.WorkerReportsProgress = true;
    updateWorker.WorkerSupportsCancellation = true;
    updateWorker.DoWork += new DoWorkEventHandler(updateWorker_DoWork);
    updateWorker.RunWorkerCompleted +=
        new RunWorkerCompletedEventHandler(updateWorker_RunWorkerCompleted);
    updateWorker.ProgressChanged +=
        new ProgressChangedEventHandler(updateWorker_ProgressChanged);

    //Run worker
    _canCancelWorker = true;
    updateWorker.RunWorkerAsync();
    //Initial Progress zero percent event
    _thes.UpdateProgress(0);
}
InformationsquelleAutor James | 2010-08-13
  1. 3

    Pour votre RunWorkerAsync() vous pouvez passer n'importe quel argument vous le souhaitez. Vous pouvez simplement mettre un Func() ou Action() en elle et dans votre DoWork() que vous venez de convertir l'objet en arrière à ce type spécifique et de l'appeler.

    Exemples sont ici et ici.

    private void InitializeBackgroundWorker()
{
    _Worker = new BackgroundWorker();

    //On a call cast the e.Argument to a Func<TResult> and call it...
    //Take the result from it and put it into e.Result
    _Worker.DoWork += (sender, e) => e.Result = ((Func<string>)e.Argument)();

    //Take the e.Result and print it out
    //(cause we will always call a Func<string> the e.Result must always be a string)
    _Worker.RunWorkerCompleted += (sender, e) =>
    {
        Debug.Print((string)e.Result);
    };
}

private void StartTheWorker()
{
    int someValue = 42;

    //Take a method with a parameter and put it into another func with no parameter
    //This is called currying or binding
    StartTheWorker(new Func<string>(() => DoSomething(someValue)));

   while(_Worker.IsBusy)
       Thread.Sleep(1);

   //If your function exactly matches, just put it into the argument.
   StartTheWorker(AnotherTask);
}

private void StartTheWorker(Func<string> func)
{
    _Worker.RunWorkerAsync(func);
}

private string DoSomething(int value)
{
    return value.ToString("x");
}

private string AnotherTask()
{
    return "Hello World";
}
    • Merci. Alors, quel serait le type d'argument si je voulais passer le délégué dans le StartTheWorker fonction. Essentiellement, je veux être en mesure d'appeler StartTheWorker(DoSomething) et ont DoSomething exécuter en tant que travailleur de fond
    • C'est juste un autre gestionnaire d'être construit avec Func(). J'ai mis à jour l'exemple pour refléter cela.
    InformationsquelleAutor Oliver
  2. 2

    Si je n'ai pas mal vous comprendre, vous avez besoin des expressions lambda pour construire méthode anonyme.

    updateWorker.DoWork += (sender,e)=>
  {
      //bla
  }

    Maintenant, vous n'avez pas besoin de toujours écrire une méthode et de le passer à new DoWorkEventHandler(myMethod)

    InformationsquelleAutor Cheng Chen
  3. 1

    Travaillé dessus, a été plus simple que je ne le pensais. Juste eu à faire un délégué pour la méthode appelée sur DoWork. Devrait probablement avoir formulé ma question initiale mieux.

        public delegate void DoWorkDelegate(object sender,DoWorkEventArgs e);

     public void GetUpdates()
     {
         StartWorker(new DoWorkDelegate(updateWorker_DoWork));
     }

     public void StartWorker(DoWorkDelegate task)
     {
         //Set up worker
         updateWorker.WorkerReportsProgress = true;
         updateWorker.WorkerSupportsCancellation = true;
         updateWorker.DoWork += new DoWorkEventHandler(task);
         updateWorker.RunWorkerCompleted +=
             new RunWorkerCompletedEventHandler(updateWorker_RunWorkerCompleted);
         updateWorker.ProgressChanged +=
             new ProgressChangedEventHandler(updateWorker_ProgressChanged);

         //Run worker
         _canCancelWorker = true;
         updateWorker.RunWorkerAsync();
         //Initial Progress zero percent event
         _thes.UpdateProgress(0);
     }

      private void updateWorker_DoWork(object sender, DoWorkEventArgs e)
      {
          BackgroundWorker worker = sender as BackgroundWorker;
          e.Result = GetUpdatesTask(worker, e);
      }
    InformationsquelleAutor James