BackgroundWorker mit Dispatcher scheint nicht, etwas zu tun

Ich versuche zu aktualisieren ObservableCollection ist, dass Daten an die Benutzeroberfläche. Ich weiß, dass dies zu tun muss ich verwenden Dispatcher und BeginvInvoke(), und es so zu machen, dass die UI nicht einfrieren, wenn ich so tun, mit einem BackgroundWorker ist ein guter Weg, um darüber zu gehen. In jedem Fall, ich habe all dies, kompiliert und ausgeführt, aber nichts passiert. Ich brauche für die Aktualisierung der Benutzeroberfläche, alle 2 Minuten oder so, also ich bin auch mit einem DispatcherTimer

Dies funktioniert, weil DispatcherTimer ist Teil der Dispatcher, aber friert das UI:

DispatcherTimer dispTimer = new DispatcherTimer();
dispTimer.Tick += dispTimer_Tick;
dispTimer.Interval = new TimeSpan(0, 0, 45);
dispTimer.Start();

private void dispTimer_Tick(object sender, EventArgs e)
{
    PartialEmployees.Clear();          
}

So, mithilfe der BackgroundWorker-ich sammelte diese:

DispatcherTimer dispTimer = new DispatcherTimer();
dispTimer.Tick += dispTimer_Tick;
dispTimer.Interval = new TimeSpan(0, 0, 45);
dispTimer.Start();

private void dispTimer_Tick(object sender, EventArgs e)
{
    BackgroundWorker _worker = new BackgroundWorker();
    _worker.DoWork += DoWork;            
    _worker.RunWorkerAsync();

}

private void DoWork(object sender, DoWorkEventArgs e)
{            
    Dispatcher.CurrentDispatcher.BeginInvoke( new Action(()=> 
        {
            PartialEmployees.Clear();
        }));
}

Aber nichts geschieht, um das UI. Das, was ich bin fehlt/nicht tun, richtig?

InformationsquelleAutor LobalOrning | 2010-11-17
  1. 3

    Haben Sie zwei Probleme:

    1. Wenn Sie Dispatcher.CurrentDispatcher von der hintergrund-thread, es ist immer die hintergrund-thread-Dispatcher, nicht der UI thread Dispatcher.

    2. Aus Ihrer Beschreibung entnehme ich, dass Ihr PartialEmployees.Clear() Methode nimmt erhebliche Zeit ausführen, und Sie möchten vermeiden, sperren Sie den UI-thread während der Ausführung. Allerdings, mit einem BackgroundWorker aufrufen PartialEmployees.Clear() auf Ihrem UI-Faden hat die gleiche Wirkung wie die Verwendung der DispatcherTimer, so müssen Sie eine andere Lösung als die, die Sie für gehen.

    Wenn Sie nur wollen, zu beheben, der Dispatcher.CurrentDispatcher problem, nur speichern der aktuellen Dispatcher in einer lokalen Variablen wie diese:

    private void dispTimer_Tick(object sender, EventArgs e) 
{
  var uiDispatcher = Dispatcher.CurrentDispatcher;

  BackgroundWorker _worker = new BackgroundWorker(); 
  _worker.DoWork += (sender, e) =>
    uiDispatcher.BeginInvoke(new Action(() =>
    {
      PartialEmployees.Clear();
    }));
  _worker.RunWorkerAsync(); 
}

    Dadurch wird die Benutzeroberfläche ändern, um zu arbeiten, aber es wird immer noch sperren Sie die Benutzeroberfläche, während die ändern, gerade so, als ob Sie noch nicht verwendet hatten, der BackgroundWorker-Klasse. Der Grund dafür ist:

    1. Die DispatcherTimer feuert, Ausführung im UI-thread. Alles was es tut (dispTimer_Tick), ist starten Sie eine BackgroundWorker-und dann beenden.
    2. Der BackgroundWorker-Klasse wird auf seine eigenen therad. Alle es tut, ist, planen Sie einen Dispatcher callback und dann beenden.
    3. Der Dispatcher callback führt auf dem UI-thread wieder. Es fordert PartialEmployees.Clear () - das dauert eine Weile, zu sperren bis der UI thread während es ausgeführt wird.

    Also Ihr Verhalten ist das gleiche, als wenn die DispatcherTimer-callback aufgerufen hatte PartialEmployees.Clear() direkt: In jedem Fall wird der zeitaufwändige Vorgang ausgeführt wird auf dem UI-thread.

    Den Grund für die Systemabstürze ist, dass jedes mal, wenn Sie ein großes Stück Arbeit auf dem UI-thread erhalten Sie eine momentane blockieren, während es ausgeführt wird. Die Lösung ist, brechen Sie Ihre Arbeit in kleinere Portionen und tun Sie eine zu einem Zeitpunkt entweder von einem DispatcherTimer oder ein BackgroundWorker. In Ihrem Fall ist, überprüfen Sie den code für PartialEmployees.Clear() um zu sehen, ob es kann getan werden, inkrementell.

    • Ok.Vielleicht bin ich verwirrt. Ist das nicht der Zweck von BackgroundWorker, um die Arbeit im hintergrund, so dass die UI nicht einfrieren; dann verwenden Dispatcher marshall die änderungen an den UI-thread? Ich bin mit Entity Framework, .Clear() ist gebaut für Listen. Ich will nicht zu tun, Arbeit im UI-thread, ich will einfach nur, um die "Aktualisierung" der Listen, die an der Benutzeroberfläche. Ich denke, dass dies vielleicht nicht möglich und ich muss nur in einen Fortschrittsbalken, so dass der Benutzer weiß, dass etwas geschieht, und die Anwendung ist nicht gefroren.
    • In diesem Fall werden Sie wahrscheinlich benötigen, binden von UI zu einer Kollektion, die nicht verwaltet von EntityFramework, und wenn das EntityFramework Sammlung feuert CollectionChanged, verwenden Dispatcher.Aufrufen, um die entsprechende änderung in die gebundene Sammlung, so dass die UI-gebundene Sammlung aktualisiert, die auf dem UI-thread. Sie sind Recht über den Zweck der BackgroundWorker-Klasse, und in der Tat, es wird nach Ihrem Zweck für den be von Daten mittels Entity Framework. Und so lange, wie Sie aktualisieren Sie Ihre Benutzeroberfläche in kleine Stücke, die UI nicht einfrieren.
    InformationsquelleAutor Ray Burns
  2. 1

    Das problem hier ist, dass Sie mit der Methode Dispatcher.CurrentDispatcher aus dem Boden zurück thread. Was Sie brauchen, ist die Dispatcher Instanz für den UI-thread. 

    _worker.DoWork += delegate { DoWork(Dispatcher.CurrentDispatcher); };

...
private void DoWork(Dispatcher dispatcher) {
  dispatcher.BeginInvoke(new Action(() => {
    PartialEmployees.Clear();
  });
}
    • Sie können auch einfach tun MainWindow.Dispatcher oder App.Aktuelle.Dispatcher (vorausgesetzt, Sie sind nicht etwas zu tun tricky wie laufen runloops auf > 1 thread)
    • Das hat nicht funktioniert entweder, so scheint es zu sein, tun die Arbeit, aber die UI ändert sich nicht. Ich denke, dass ich nicht mit den UI-dispatcher, so dass Ihr die Arbeit macht, auf einen anderen thread und dann die UI würde nicht immer wissen. Ich könnte das nicht MainWindow.Dispatcher, weil "ein Objektverweis erforderlich" ... nicht sicher, was diese sich bezieht.
    InformationsquelleAutor JaredPar
  3. 0

    Ich glaube nicht, Sie müssen die Arbeit im hintergrund, als BeginInvoke auf die Dispatcher läuft auf einem Threadpool-thread.

    so etwas sollte funktionieren, und ist kurz und bündig

    DispatcherTimer dispTimer = new DispatcherTimer 
    {Interval = TimeSpan.FromSeconds(45)};
dispTimer.Tick += (o,e) => Dispatcher.CurrentDispatcher
    .BeginInvoke((Action)PartialEmployees.Clear);
dispTimer.Start();
    InformationsquelleAutor Dean Chalk
Schreibe einen Kommentar