Hallo,

als erstes muss ich sagen, daß ich wirklich lange im Netz und hier gesucht habe, aber leider keine Antwort auf meine Frage gefunden habe.

Ich habe hier ein Form mit einem DataGridView. Die BindingSource des Datagridviews fülle ich mit einem Backgroundworker und möchte nun auf einem Dialogfensterchen anzeigen, wie weit das Einlesen schon gekommen ist.

Form:

Private Sub LoadDataBgwDoWork(sender As System.Object, _
   e As System.ComponentModel.DoWorkEventArgs) _
   Handles LoadDataBGW.DoWork

   _blv.DataSource.Clear()
'''...
   ' Fortschritt mitteilen
   While (s < _designOrders.Count())
    LoadDataBGW.ReportProgress(CInt((s * 1.0) / _designOrders.Count() * 100.0), _designOrders.Skip(s).Take(Pagesize).ToList())
    s += Pagesize
   End While

  End Sub

  Private Sub LoadDataBGWProgressChanged(sender As System.Object, _
   e As System.ComponentModel.ProgressChangedEventArgs) _
   Handles LoadDataBGW.ProgressChanged

   Try
    For Each o In DirectCast(e.UserState, List(Of OrderDataGridViewModelRow))
     _blv.DataSource.Add(o)
    Next
    _waitDialog.Progress = e.ProgressPercentage

   Catch ex As Exception
    Console.WriteLine(ex)
   End Try

  End Sub

WarteDialog:

Public Property Progress As Integer
  Get
   Return ProgressBar1.Value
  End Get
  Set(value As Integer)
   If ProgressBar1.Value <> value _
    AndAlso value >= ProgressBar1.Minimum _
    AndAlso value <= ProgressBar1.Maximum Then

    ProgressBar1.Value = value
   End If
  End Set
  End Property

Nun passiert folgendes, der Wartedialog wird angezeigt, er arbeitet wie wild und der Progressbar bewegt sich kein Stück. Und dann ist er auch schon fertig und der Dialog wird wieder ausgeblendet.

Wenn ich in die Schleife eine Thread.Sleep(1000) einbaue, klappt es wunderbar, aber ich will ja, daß die Daten schnell geladen werden und der Vorgang nicht noch zusätzlich verlangsamt wird. Es hat also mit der Aktualisierung der Anzeige zu tun. Aber weder ein .Refresh, noch ein .Update oder ein .DoEvents() haben den gewünschten Erfolg gebracht.

Hat noch jemand eine Idee?

LG,

BaNDiT

Hm, nach Lesen Deines aktualisierten Code-Beispiels: wenn ich das richtig verstehe, hast Du im DowWork-Handler die zu ladenden Daten komplett auf einen Schlag verfügbar - gekapselt durch das OrderDataGridViewModel (falls das VM IEnumerable oder sowas implementiert: die Count()- und Skip()-Aufrufe dürften jeden Versuch von Lazy Loading torpedieren). Danach sollen diese Daten zeilenweise in die BindingSource übertragen werden, und für diesen Prozeß möchtest Du eine Fortschrittsanzeige.

Richtig?

Dann denke ich, dass das mit dem BGW so nicht funktioniert oder dessen Idee zuwider läuft. das Befüllen einer BindingSource ist eine UI-Aufgabe - nicht umsonst brauchst Du ein Invoke(). Der BGW ist aber dafür da, langlaufende Aufgaben in einen separaten Nicht-UI-Thread zu verschieben und derweil das UI am Leben zu halten und optional darüber zu informieren, was da so im Hintergrund vor sich geht. Damit das einen Sinn ergibt, muß aber die zeitintensive Arbeit im Background-Thread erfolgen. Du blockierst Dir aber den UI-Thread durch das zeilenweise Befüllen der BindingSource, während der Worker-Thread kaum etwas zu tun bekommt.

Wenn das Befüllen tatsächlich so lange dauert, dass Du eine Fortschrittsanzeige dafür brauchst, mußt Du zwei parallele Aufgabe im UI-Thread koordinieren und Dir bewußt sein, daß es dadurch tendenziell etwas langsamer wird. Der BGW dürfte dann eher nicht das richtige Werkzeug dafür sein, eine normale Schleife wäre dann wohl besser, bei der alle n Durchläufe die ProgressPercentage erhöht wird.
Ich würde aber erst mal versuchen, die Daten auf einen Schlag einzufüllen (_blw.DataSource = _designOrders, statt Add()). Das sollte eigentlich nicht so ewig dauern, und wenn doch, dann würde mal nachschauen, wieso.

Aus dem kleinen Stück was du gepostet hast kann man leider einige sachen nicht erkennen.

Ein zwei typische Fehler sind:

• WorkerReportsProgress fehlt
  

  LoadDataBGW.WorkerReportsProgress = True

  
  
• Invoke in den UI-Thread fehlt
  Als C#-Code:
  

  if(this.InvokeRequired) {
       this.Invoke(new MethodInvoker(() => LoadDataBGWProgressChanged(sender, args)));
       return;
     }

  
  
  

  Private Sub LoadDataBgwDoWork(sender As System.Object, _
     e As System.ComponentModel.DoWorkEventArgs) _
     Handles LoadDataBGW.DoWork
  
     _blv.DataSource.Clear()
      '''...
     ' Fortschritt mitteilen
     While (s < _designOrders.Count())
      
      ' \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/
      DirectCast(sender, System.ComponentModel.BackgroundWorker).ReportProgress(CInt((s * 1.0) / _designOrders.Count() * 100.0), _designOrders.Skip(s).Take(Pagesize).ToList())
      
      s += Pagesize
     End While
  
    End Sub

  
  

  Private Sub LoadDataBGWProgressChanged(sender As System.Object, _
     e As System.ComponentModel.ProgressChangedEventArgs) _
     Handles LoadDataBGW.ProgressChanged
  
     '\/ C# Code den du in VB.Net übersetzten musst
     '\/ sorgt dafür das du in den UI-Thread wechselst
     if(this.InvokeRequired) {
       this.Invoke(new MethodInvoker(() => LoadDataBGWProgressChanged(sender, args)));
       return;
     }
  
     Try
      For Each o In DirectCast(e.UserState, List(Of OrderDataGridViewModelRow))
       _blv.DataSource.Add(o)
      Next
      _waitDialog.Progress = e.ProgressPercentage
  
     Catch ex As Exception
      Console.WriteLine(ex)
     End Try
  
    End Sub

  
  

EDIT, Neue These:

Das Problem könnte sein, das der UI-Thread mit dem befüllen der DataGridView beschäftigt ist (also dem was du im DoWork-Handler machst) und nicht dazu kommt die ProgressChanged-Events die von ReportProgress ausgelöst werden abzuarbeiten.
Das würde auch erklären warum ein Thread-Sleep(1000) das Problem beseitigt.

Eine Möglichkeit wäre ReportProgress nur jede Sekunden oder nach erreichen bestimmte Meilensteine auszulösen und im Anschluss mit Thread.Sleep(100) dem UI-Thread die möglichkeit zu geben das Event abzuarbeiten.

Private Sub LoadDataBgwDoWork(sender As System.Object, _
   e As System.ComponentModel.DoWorkEventArgs) _
   Handles LoadDataBGW.DoWork
   
   Dim lastUpdate as DateTime = DateTime.Min
   _blv.DataSource.Clear()

    '''...
   ' Fortschritt mitteilen
   While (s < _designOrders.Count())
    'ReportProgress nur einmal pro Sekunden auslösen
    if (DateTime.Now - lastUpdate).TotalMilliseconds < 1000 then
      DirectCast(sender, System.ComponentModel.BackgroundWorker).ReportProgress(CInt((s * 1.0) / _designOrders.Count() * 100.0), _designOrders.Skip(s).Take(Pagesize).ToList())
      lastUpdate = DateTime.Now
      Thread.Sleep(100); '100 Millisekunden warten um den UI-Thread die Möglichkeit zu geben das Event abzuarbeiten
    end if
    s += Pagesize
   End While

  End Sub

In welche Schleife hast Du denn den Sleep eingebaut? In DoWork oder in ProgressChanged?

Was ich merkwürdig finde: Du benutzt ProgressChanged für das Befüllen der DataSource. Nach meinem Verständnis ist ProgressChanged aber nur für das Aktualisieren der Fortschrittsanzeige gedacht.

Was ist denn wirklich langsam? Das Einlesen der Daten oder das Befüllen der DataSource? Könntest Du nicht auch erst mal alle Daten einlesen, dabei über den Fortschritt berichten und dann in einer Aktion die DataSource befüllen, und zwar in RunWorkerCompleted? Ich kann zwar nicht erklären, warum es zu der Blockade kommt (und vielleicht fehlen dazu auch ein paar wichtige Infos in Deiner Frage), aber ich glaube, so haben sie sich das bei Microsoft gedacht.

Übrigens: _blv.DataSource.Clear() würde ich aus dem DoWork-Handler herausnehmen und vor dem Aufruf von RunWorkerAsync (oder auch erst in RunWorkerCompleted, wenn Du meinem Vorschlag folgst) ausführen. Das zieht ja auch eine UI-Aktualisierung nach sich...

versuch mal das hier:

Dim lastUpdate as DateTime = DateTime.Min

   While (s < _designOrders.Count())
    FillData(_designOrders.Skip(s).Take(Pagesize).ToList())

    'ReportProgress nur einmal pro Sekunden auslösen
    if (DateTime.Now - lastUpdate).TotalMilliseconds > 1000 then '>1000 nicht <1000
          DirectCast(sender, System.ComponentModel.BackgroundWorker).ReportProgress(CInt((s * 1.0) / _designOrders.Count() * 100.0), Nothing)
      lastUpdate = DateTime.Now
      Thread.Sleep(100)
    end if
    s += Pagesize
   End While

Um den UI-Thread Zeit zu geben das Event auch abzuarbeiten.
Das Delegate ist im Prinzip nur ein Funktionszeiger. Das Invoke beschäftigt weiterhin den UI-Thread, also musst du selbigem Zeit einräumen das Event auch abzuarbeiten.