Wie kann ich bis zum Abschluss von BackgroundWorker warten?

Warten, bis der Arbeitsthread im hintergrund ausgeführt (einzelne oder mehrere) Folgendes tun:

1. Erstellen Sie eine Liste von Hintergrund-Arbeitnehmer haben Sie ein Programm erstellt:

   private IList<BackgroundWorker> m_WorkersWithData = new List<BackgroundWorker>();

2. Fügen Sie den background-worker in der Liste:

   BackgroundWorker worker = new BackgroundWorker();
   worker.DoWork += new DoWorkEventHandler(worker_DoWork);
   worker.ProgressChanged += new ProgressChangedEventHandler(worker_ProgressChanged);
   worker.WorkerReportsProgress = true;
   m_WorkersWithData.Add(worker);
   worker.RunWorkerAsync();

3. Verwenden Sie die folgende Funktion zu warten für alle Arbeitnehmer in der Liste:

   private void CheckAllThreadsHaveFinishedWorking()
   {
       bool hasAllThreadsFinished = false;
       while (!hasAllThreadsFinished)
       {
           hasAllThreadsFinished = (from worker in m_WorkersWithData
                                    where worker.IsBusy
                                    select worker).ToList().Count == 0;
           Application.DoEvents(); //This call is very important if you want to have a progress bar and want to update it
                                   //from the Progress event of the background worker.
           Thread.Sleep(1000);     //This call waits if the loop continues making sure that the CPU time gets freed before
                                   //re-checking.
       }
       m_WorkersWithData.Clear();  //After the loop exits clear the list of all background workers to release memory.
                                   //On the contrary you can also dispose your background workers.
   }

InformationsquelleAutor der Antwort Azhar Khorasany

Diese Frage ist alt, aber ich glaube nicht, dass der Autor bekam die Antwort die er suchte.

Dies ist ein bisschen schmutzig, und es ist in vb.NET aber für mich funktioniert

Private Sub MultiTaskingForThePoor()
    Try
        'Start background worker
        bgwAsyncTasks.RunWorkerAsync()
        'Do some other stuff here
        For i as integer = 0 to 100
            lblOutput.Text = cstr(i)
        Next

        'Wait for Background worker
        While bgwAsyncTasks.isBusy()
            Windows.Forms.Application.DoEvents()
        End While

        'Voila, we are back in sync
        lblOutput.Text = "Success!"
    Catch ex As Exception
        MsgBox("Oops!" & vbcrlf & ex.Message)
    End Try
End Sub

InformationsquelleAutor der Antwort goughy000

Überprüfung backgrWorker.IsBusy in der Schleife mit Application.DoEvents() ist nicht schön Weise.

Stimme ich mit @JohannesH, sollte man definitiv nutzen AutoResetEvent als eine elegante Lösung. Aber nicht, indem Sie es in UI-Thread, es führt dazu, dass Haupt-thread blockiert, und es sollte kommen aus einem anderen hintergrund-worker-thread.

AutoResetEvent aevent = new AutoResetEvent(false);    
private void button1_Click(object sender, EventArgs e)
{
    bws = new BackgroundWorker();
    bws.DoWork += new DoWorkEventHandler(bw_work);
    bws.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_complete);
    bws.RunWorkerAsync();

    bwWaiting.DoWork += new DoWorkEventHandler(waiting_work);
    bwWaiting.RunWorkerCompleted += new RunWorkerCompletedEventHandler(waiting_complete);
    bwWaiting.RunWorkerAsync();
}

void bw_work(object sender, DoWorkEventArgs e)
{
    Thread.Sleep(2000);
}

void bw_complete(object sender, RunWorkerCompletedEventArgs e)
{
    Debug.WriteLine("complete " + bwThread.ToString());
    aevent.Set();
}
void waiting_work(object sender, DoWorkEventArgs e)
{
    aevent.WaitOne();
}

void waiting_complete(object sender, RunWorkerCompletedEventArgs e)
{
    Debug.WriteLine("complete waiting thread");
}

InformationsquelleAutor der Antwort KevinBui

In OpenCV exists-Funktion WaitKey. Ir erlaubt, dieses Problem zu lösen, das in dieser Weise:

while (this->backgroundWorker1->IsBusy) {
    waitKey(10);
    std::cout << "Wait for background process: " << std::endl;
}
this->backgroundWorker1->RunWorkerAsync();

InformationsquelleAutor der Antwort csc

Ich verwendet Aufgaben mit einem BackgroundWorker

Können Sie eine beliebige Anzahl von Aufgaben, und fügen Sie zu einer Liste von Aufgaben.
Die Arbeiter beginnen, wenn eine Aufgabe Hinzugefügt wird, neu zu starten, wenn eine Aufgabe Hinzugefügt wird, während der Arbeiter IsBusy, und Stoppt, sobald es gibt keine weiteren Aufgaben mehr.

Wird diese ermöglichen es Ihnen, ein update des GUI asynchron, so viel, wie Sie benötigen, ohne zu frieren.

Dieser funktioniert wie für mich.

    //'tasks' is simply List<Task> that includes events for adding objects
    private ObservableCollection<Task> tasks = new ObservableCollection<Task>();
    //this will asynchronously iterate through the list of tasks 
    private BackgroundWorker task_worker = new BackgroundWorker();

    public Form1()
    {
        InitializeComponent();
        //set up the event handlers
        tasks.CollectionChanged += tasks_CollectionChanged;
        task_worker.DoWork += task_worker_DoWork;
        task_worker.RunWorkerCompleted += task_worker_RunWorkerCompleted;
        task_worker.WorkerSupportsCancellation = true;

    }

    //----------- worker events
    void task_worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        if (tasks.Count != 0)
        {
            task_worker.RunWorkerAsync();
        }
    }

    void task_worker_DoWork(object sender, DoWorkEventArgs e)
    {
        try
        {

            foreach (Task t in tasks)
            {
                t.RunSynchronously();
                tasks.Remove(t);
            }
        }
        catch
        {
            task_worker.CancelAsync();
        }
    }


    //------------- task event
    //runs when a task is added to the list
    void tasks_CollectionChanged(object sender,
        System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
    {
        if (!task_worker.IsBusy)
        {
            task_worker.RunWorkerAsync();
        }
    }

Alles was Sie jetzt brauchen, ist eine neue Aufgabe erstellen, und fügen Sie es an die List<>. Es wird ausgeführt werden, indem die Arbeiter in der Reihenfolge in der Liste<>

Task t = new Task(() => {

        //do something here
    });

    tasks.Add(t);

InformationsquelleAutor der Antwort Beefjeff