Backgroundworker das RunWorkerCompleted-Ereignis ausgelöst noch vor Abschluss der arbeiten

Ich bin mit dem BackgroundWorker thread eine lange Aufgabe ausführen(im Grunde das Lesen eine große xml-Datei). Für die erste Zeit, die der Arbeiter arbeitet fein wie gewünscht, aber wenn ich hochladen eine zweite xml-Datei, mit dem gleichen hintergrund-worker funktioniert es manchmal, aber die meiste Zeit der Backgroundworker ist RunWorkerCompleted ausgelöst wird, noch bevor der DoWork-Ereignis. Einige der code, der unten angezeigt wird

    private void openFile_Click(object sender, RoutedEventArgs e)
    {
          //Code removed for brevity
  worker = new BackgroundWorker();
            worker.RunWorkerAsync();
            worker.DoWork += new DoWorkEventHandler(worker_DoWork);
            worker.WorkerReportsProgress = true;
            worker.ProgressChanged += new ProgressChangedEventHandler(worker_ProgressChanged);
            worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);
       }

        void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        DataImport();
        //worker.Dispose();
        //worker.Disposed += new EventHandler(worker_Disposed);
        //worker.DoWork -= worker_DoWork;
        //worker.RunWorkerCompleted -= worker_RunWorkerCompleted;
        //worker = null;
        //GC.Collect(GC.GetGeneration(worker), GCCollectionMode.Forced);
    }

Arbeitnehmer ist eine Global definierte variable. Was ist hier falsch bin ich nicht immer. Bitte helfen

  • Ein paar Tipps zum Abschluss: Don ' T call GC.Collect(), Tun, überprüfen e.Error.
  • Nicht zu beantworten, w/o zu sehen, mindestens eine Kontur in der DoWork().
  • Wenn Ihr DoWork-Funktion erstellt einen thread für die Durchführung Ihrer Arbeit, und Sie nicht .Join(), DoWork wird schlagartig wieder. Aber wie @Henk sagte, müssen sehen, was DoWork tut.
InformationsquelleAutor Vikram | 2013-07-29
  1. 9

    Sollten Sie die DoWork-event-handler (und alle anderen event-handler, die auch vor aufrufen RunWorkerAsync().

    Ansonsten könnte es passieren, dass RunWorkerAsync macht praktisch nichts.

    • Wahr, aber nicht wirklich erklären, warum die Symptome "ausgelöst wird, noch bevor der DoWork-Ereignis".
    • Vielleicht wollen Sie auch zu erwähnen, da er wieder mit dem Arbeiter, daß er Sie machen sollte sicher nicht zum hinzufügen von event-Handler mehrere Male.
    • Auch er ist wieder mit dem event-Handler, so vielleicht die RunWorkerCompleted Ereignis, das ausgelöst wird, gehört nicht zu den "aktuellen" hintergrund-Arbeiter.
    • Die OP ist die Schaffung einer neuen Bgw jeder Zeit. Und die auskommentierte code wirklich versucht, Sie auszurotten, die alten. Beide sind ausreichend, um auszuschließen, die Wiederverwendung von Prozeduren.
    • Vielen Dank für die Antwort. Aber warum ist es so, RunWorkerCompleted-Ereignis sollte nur ausgeführt wird, wenn der Arbeiter fertig ist mit seiner Arbeit-unabhängig davon, wo wir bei der Zuweisung einer handler an das Ereignis. Irgendeine Idee ?
    • RunWorkerCompleted += ... ist nicht aufgerufen wird, von Ihnen aber durch den BackgroundWorker. Du bist nur die Zuordnung der Arbeit für es zu gehen, wenn es bestimmt, es ist der geeignete Zeitpunkt, dies zu tun. Noch wichtiger ist, müssen Sie ordnen die DoWork+= vor runworkerasync erfasst() auf das gleiche Konzept -, dass die BGW benötigt einen zugeordneten Funktion, wenn er entscheidet, dass es Zeit ist, um mit einem konkreten Ereignis. Runworkerasync erfasst wird gestartet, und wenn festgestellt wird, dass Ressourcen verfügbar sind, genug ist, wird es beginnen die zugewiesene "DoWork". Wenn "DoWork" abgeschlossen hat die BGW wissen, und werde dann schauen, um zu sehen, wenn "Abgeschlossen" zugeordnet ist.

    InformationsquelleAutor sloth
  2. 2

    Es sollte wie folgt sein:

    worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;

worker.DoWork += new DoWorkEventHandler(worker_DoWork);
worker.ProgressChanged += 
    new ProgressChangedEventHandler(worker_ProgressChanged);
worker.RunWorkerCompleted += 
    new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);

worker.RunWorkerAsync();

    RunWorkerAsync sollte aufgerufen werden, nachdem die Anmeldung auf der DoWork und RunWokerCompleted Veranstaltungen.

    InformationsquelleAutor Vishal
  3. 2

    sollten Sie zuerst überprüfen, dass der hintergrund Arbeiter beschäftigt ist oder nicht, mit dieser....

            backgroundWorker1.DoWork += backgroundWorker1_DoWork;
        backgroundWorker1.RunWorkerCompleted += backgroundWorker1_RunWorkerCompleted;
            if (backgroundWorker1.IsBusy)
        {
            backgroundWorker1.CancelAsync();
        }
        else
        {
            backgroundWorker1.RunWorkerAsync();

        }
    InformationsquelleAutor Mukesh Kumar
  4. 0

    Wie gesagt in https://stackoverflow.com/a/16809596/8029935, können Sie blind werden, vorausgesetzt, dass der worker beendet den job und produziert ein Ergebnis, wenn die DoWork-Methode stirbt eine Ausnahme. Die ist gefangen von der BackgroundWorker-Klasse, und übergeben Sie das RunWorkerCompleted-Ereignis-handler als e.Error-Eigenschaft.

    So, ich schlage vor, Sie müssen überprüfen, dass die Eigenschaft über einen try/catch-Anweisung.

    InformationsquelleAutor Eduardo Arruda
Schreibe einen Kommentar