Progress Form/Dialog VCL

[lxo]

Hallo,

folgende/s Frage/Problem habe ich.
Ich habe eine Funktion die Daten aus Textdateien in eine Datenbank importiert.
Da in den Textdateien einige tausend Datensätze enthalten sind, dauert dies ein paar Sekunden.

Für diesen Fall würde ich gerne eine Fortschrittsanzeige anzeigen.
Jedoch nicht direkt auf meinem Form sondern auf einem extra Dialog/Form der/das im Vordergrund steht und weiterhin bedienbar ist, die Form im Hintergrund sollte während dessen blockiert sein.

Momentan habe ich einfach beim starten des Imports eine zweite Form geöffnet, die ich während des Import immer mal wieder aktualisiere in dem ich den Text ändere bzw. die Position einer Progessbar hochzähle und ein Application.ProcessMessages auslöse.

Das funktioniert, leider nicht so wie ich das möchte.

Je öfter ich Application.ProcessMessages auslöse umso langsamer wird der Import.
Wenn ich jedoch Application.ProcessMessages nicht so oft auslöse, hängt die Fortschrittsanzeige bis ich wieder Application.ProcessMessages auslöse, auch bei Progessbar.Style [pbstMarquee].

Ich hab schon alles mögliche mit Threads probiert, nur irgendwie kriege ich es einfach nicht hin...

Also, ich hätte gerne einfach einen weiteren Dialog der den Fortschritt meines Imports live anzeigt und weiterhin bedienbar ist und das HauptFormular blockiert.



Kann mir da jemand paar Tipps geben?

[API]

Hast du so etwas in dieser Art schon probiert?


https://www.thoughtco.com/synchroniz...cation-1058159

[Delphi.Narium]

Wie änderst Du die Progressbar?

Mal ein Beispiel (schemahaft):

Delphi-Quellcode:

begin
  Stringliste.LoadFromFile('irgendeine.datei');
  Progressbar.Min := 0;
  Progressbar.Position := 0;
  Progressbar.Max := Stringliste.Count;
  for i := 0 to Stringliste.Count - 1 do begin
    FunktionDieDieZeileIndDiDatenbankBringt(Stringliste[i]);
    if i Mod 100 = 0 then  // statt der 100 was Größeres oder Kleineres nehmen, jenachdem, wie schnell das Ganze ist ...
      Progressbar.Position := i;
      Application.ProcessMessages;
    end;
  end;
end;

[dummzeuch]

Zitat:

Zitat von lxo (Beitrag 1414451)

Je öfter ich Application.ProcessMessages auslöse umso langsamer wird der Import.

Eine Möglichkeit wäre, vor einem Aufruf von Application.ProcessMessages zu prüfen, wie lange der letzte Aufruf her ist. Erst dann, wenn das vor mehr als z.B. 100 ms war, wird dann Application.ProcessMessages aufgerufen:

Delphi-Quellcode:

var
  LastCall: Int64;
  ThisCall: Int64;

[...]
  ThisCall := GetTickCount;
  if (ThisCall - LastCall > 100) or (LastCall > ThisCall) then begin
    Application.ProcessMessage;
    LastCall := ThisCall;
  end;

[hoika]

Hallo,
oder du aktualisierst den Progressbar PB alle 5% des weiteren Datenfortschritts, also PB.Pos mod PB.Max=0 (oder so ähnlich).
Dann sind das nur 20 Aufrufe, der Nutzer sieht aber trotzdem, dass es weitergeht.

[DieDolly]

Oder man lagert den Import in einen Thread aus und schickt per PostMessage Nachrichten an WndProc oder einen eigenen MessageHandler, wertet dort die Message aus und setzt die GUI.
So blockieren sich Import und GUI nicht gegenseitig.

[Zacherl]

Im Anhang hatte ich mal den Progress-Dialog von Windows gekapselt. Vielleicht ist der ja was für dich.

[lxo]

Zitat:

Zitat von DieDolly (Beitrag 1414487)

Oder man lagert den Import in einen Thread aus und schickt per PostMessage Nachrichten an WndProc oder einen eigenen MessageHandler, wertet dort die Message aus und setzt die GUI.
So blockieren sich Import und GUI nicht gegenseitig.

Genau sowas habe ich probiert nur leider nicht richtig hingekriegt.
Hättest du da vielleicht ein Beispiel wie man so etwas angeht?

[DieDolly]

Ich bastel gleich mal eine Demo. Die Profis werden mich für den Code vermutlich zerreißen. Aber das ist das Resultat aus verschiedensten Empfehlungen.
Demo kommt gleich.

Hauptunit

Delphi-Quellcode:

type
 TForm1 ...
 private
  ...
  ProgressThread: TProgressThread;
 public
  ...
  procedure WndProc(var msg: TMessage); override;
 end;

const
 WM_PROGRESS_SET = WM_USER + 1;

implementation

{$R *.dfm}

procedure TForm1.WndProc(var msg: TMessage);
begin
 inherited;

 case msg.msg of
  WM_PROGRESS_SET:
   begin
    ProgressBar1.Position := msg.WParam;
   end;
 end;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
 ProgressBar1.Max := 1000;
 ProgressThread := TProgressThread.Create(Form1.Handle);
end;

Thread

Delphi-Quellcode:

unit uProgressThread;

interface

uses
 Winapi.Windows, System.Classes;

type
 TProgressThread = class(TThread)
 protected
 var
  DestinationWindowHandle: THandle;
 private
  {Private-Deklarationen}
 protected
  procedure Execute; override;
 public
  constructor Create(const DestinationWindowHandle: THandle);
 end;

implementation

uses Unit1;

{TProgressThread}

constructor TProgressThread.Create(const DestinationWindowHandle: THandle);
begin
 inherited Create;

 Self.DestinationWindowHandle := DestinationWindowHandle;
end;

procedure TProgressThread.Execute;
var
 i: Integer;
begin
 for i := 0 to 1000 do
  begin
   if Terminated then
    Break;

   PostMessage(DestinationWindowHandle, WM_PROGRESS_SET, i, 0);

   Sleep(25);
  end;
end;

end.

Das ist jetzt einfach nur schnell hingeschrieben. Die Kernfunktionalität (WndProc, PostMessage, Thread), sollte aber klar sein.

[lxo]

Danke für die Tipps.
Ich werde mir das diese Woche mal anschauen alles und danach berichten.

[lxo]

Zitat:

Zitat von dummzeuch (Beitrag 1414456)

Zitat:

Zitat von lxo (Beitrag 1414451)

Je öfter ich Application.ProcessMessages auslöse umso langsamer wird der Import.

Eine Möglichkeit wäre, vor einem Aufruf von Application.ProcessMessages zu prüfen, wie lange der letzte Aufruf her ist. Erst dann, wenn das vor mehr als z.B. 100 ms war, wird dann Application.ProcessMessages aufgerufen:

Delphi-Quellcode:

var
  LastCall: Int64;
  ThisCall: Int64;

[...]
  ThisCall := GetTickCount;
  if (ThisCall - LastCall > 100) or (LastCall > ThisCall) then begin
    Application.ProcessMessage;
    LastCall := ThisCall;
  end;

Also das ist ja echt simpel und funktioniert richtig gut. :thumb:
Danke für den Tipp, ich denke ich werde es erstmal so anwenden und schaue mir später genau an wie ich das mit einem Thread lösen kann.

[dummzeuch]

Zitat:

Zitat von lxo (Beitrag 1414575)

Zitat:

Zitat von dummzeuch (Beitrag 1414456)

Zitat:

Zitat von lxo (Beitrag 1414451)

Je öfter ich Application.ProcessMessages auslöse umso langsamer wird der Import.

Eine Möglichkeit wäre, vor einem Aufruf von Application.ProcessMessages zu prüfen, wie lange der letzte Aufruf her ist. Erst dann, wenn das vor mehr als z.B. 100 ms war, wird dann Application.ProcessMessages aufgerufen:

Also das ist ja echt simpel und funktioniert richtig gut. :thumb:
Danke für den Tipp

Hier ist noch mein etwas ausführlicherer Blogpost (von Samstag) dazu:

https://blog.dummzeuch.de/2018/09/29...elphi-program/

[KodeZwerg]

Zitat:

Zitat von Zacherl (Beitrag 1414500)

Im Anhang hatte ich mal den Progress-Dialog von Windows gekapselt. Vielleicht ist der ja was für dich.

Habe mal zugegriffen aber noch nicht reingeschaut, Danke fürs hochladen.

[lxo]

Zitat:

Zitat von DieDolly (Beitrag 1414526)

Ich bastel gleich mal eine Demo. Die Profis werden mich für den Code vermutlich zerreißen. Aber das ist das Resultat aus verschiedensten Empfehlungen.
Demo kommt gleich.

Hauptunit

Delphi-Quellcode:

type
 TForm1 ...
 private
  ...
  ProgressThread: TProgressThread;
 public
  ...
  procedure WndProc(var msg: TMessage); override;
 end;

const
 WM_PROGRESS_SET = WM_USER + 1;

implementation

{$R *.dfm}

procedure TForm1.WndProc(var msg: TMessage);
begin
 inherited;

 case msg.msg of
  WM_PROGRESS_SET:
   begin
    ProgressBar1.Position := msg.WParam;
   end;
 end;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
 ProgressBar1.Max := 1000;
 ProgressThread := TProgressThread.Create(Form1.Handle);
end;

Thread

Delphi-Quellcode:

unit uProgressThread;

interface

uses
 Winapi.Windows, System.Classes;

type
 TProgressThread = class(TThread)
 protected
 var
  DestinationWindowHandle: THandle;
 private
  {Private-Deklarationen}
 protected
  procedure Execute; override;
 public
  constructor Create(const DestinationWindowHandle: THandle);
 end;

implementation

uses Unit1;

{TProgressThread}

constructor TProgressThread.Create(const DestinationWindowHandle: THandle);
begin
 inherited Create;

 Self.DestinationWindowHandle := DestinationWindowHandle;
end;

procedure TProgressThread.Execute;
var
 i: Integer;
begin
 for i := 0 to 1000 do
  begin
   if Terminated then
    Break;

   PostMessage(DestinationWindowHandle, WM_PROGRESS_SET, i, 0);

   Sleep(25);
  end;
end;

end.

Das ist jetzt einfach nur schnell hingeschrieben. Die Kernfunktionalität (WndProc, PostMessage, Thread), sollte aber klar sein.

Sollte es nicht möglich sein, dem Thread die Methode zum importieren als Event mitzugeben?
Und das die Progressbar bei längeren Aktionen wie langsamen SQLs weiterhin die Progressbar aktualisiert wird z.B. in Marquee-Style ?

[DieDolly]

Mein Beispiel sollte wie gesagt nur WndProc und PostMessage veranschaulichen.
Wie man was nun weiter ausbaut usw muss jeder selber wissen.