[VCL] TCustomControl, Welche Methode für Komponente um empfangsbereit zu sein?

[4dk2]

Guten morgen zusammen,


Ich habe ne Art Logging Komponente, die Thread-safe Log-Ereignisse empfangen kann, in einer oder mehreren Dateien hinterlegen kann, und an mehreren
Stellen anzeigen kann.

Die Komponente, die die Ereignisse Live anzeigt, bereitet mir im Moment ein paar Kopfschmerzen.

Und Zwar dann, wenn Ereignisse zur Create Phase der Anwendung passieren.
Ich habe mal eine Demo erstellt (siehe Anhang)

Aber Grundsätzlicht, habe ich eine TCustomPanel, auf der Eine Listbox erstellt wird, und dort werden per
AddLog Meldungen eingetragen.

im Addlog habe ich eine Sperre, das erst Meldungen angenommen werden, wenn die Komponente dazu bereit ist,
weil ohne Sperre kommen sehr merkwürdige Windows Fehler.
Mein Aktueller "Workarround" ist es, erst nach dem Aufruf vom Paint, Meldungen zu erlauben (FAddAllowed=true).

Ich würde euch jetzt gerne Fragen, wie ich am besten die Sperre aufhebe,
sozusagen, wann kann gefahrlos eingetragen werden?
Und wann kann sicher SendMessage() aufgerufen werden für den Autoscroll?

(Es geht gar nicht darum das evtl. Daten verloren gehen, in meiner eigentlichen Komponente wird das berücksichtigt.

Delphi-Quellcode:

unit uFMain;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls,SyncObjs, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.ExtCtrls, JvExStdCtrls, JvListBox;



type
  TTestLog=class(TCustomPanel)
  private
    FAddAllowed:boolean;
    FListBox:TListBox;
    FCS_Add:TCriticalSection;
    FWorkaroundActive: boolean;
  protected
    procedure Paint; override;


  public
    property WorkaroundActive:boolean read FWorkaroundActive write FWorkaroundActive;
    procedure AddLog(Amessage:string);
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;

  end;

  TTestThread=class(TThread)
  private
    FLog:TTestLog;
  protected
    procedure Execute; override;
  public
    constructor Create(ALog:TTestLog);
    destructor Destroy; override;
    class procedure SicherFreigeben(var threadObjekt: TTestThread); static;

  end;

  TFMain = class(TForm)
    pb1: TPanel;
    btnStart: TButton;
    btnStop: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure btnStartClick(Sender: TObject);
    procedure btnStopClick(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    FLog:TTestLog;
    FT:array[0..100] of TTestThread;

    { Public-Deklarationen }
  end;

var
  FMain: TFMain;

CONST MAXTHREADS=10;


implementation

{$R *.dfm}

{ TTestLog }

procedure TTestLog.AddLog(Amessage: string);
begin
  FCS_Add.Enter;
  try
    if FAddAllowed or not FWorkaroundActive then
    begin
      FListBox.Items.Add(Amessage);

      SendMessage(FListBox.Handle, LB_SETTOPINDEX, FListBox.Items.Count-1, 0);
      FListBox.Update;
      self.Update;
    end;
  finally
    FCS_Add.Leave;
  end;
end;

constructor TTestLog.Create(AOwner: TComponent);
begin
  inherited;
  FCS_Add:=TCriticalSection.Create;
  FListBox:=TListBox.Create(self);
  FListBox.Parent:=self;
  FListBox.Align:=alClient;
  FListBox.Color:=clBlack;
  FListBox.Font.Color:=clWhite;
end;

destructor TTestLog.Destroy;
begin
  FCS_Add.Free;
  FListBox.Free;
  inherited;
end;

procedure TTestLog.Paint;
begin
  inherited;
  if FWorkaroundActive then
    FAddAllowed:=true;
end;


{ TTestThread }



constructor TTestThread.Create(ALog: TTestLog);
begin
  inherited Create(false);

  FLog:=ALog;

end;

destructor TTestThread.Destroy;
begin
  FLog:=nil;
  inherited;
end;

procedure TTestThread.Execute;
begin

  while not Terminated do
  begin
    if Assigned(FLog) then
      FLog.AddLog('THREAD: '+inttostr(ThreadID)+' TESTLOG');
    sleep(100);
  end;

end;

class procedure TTestThread.SicherFreigeben(var threadObjekt: TTestThread);
begin
  if assigned(threadObjekt) then
  begin
    threadObjekt.Terminate;
    threadObjekt.WaitFor;
    threadObjekt.free;
    threadObjekt:=nil;
  end;
end;


procedure TFMain.btnStartClick(Sender: TObject);
var
  I: Integer;
begin
  for I := low(ft) to MAXTHREADS-1 do
    FT[i]:=TTestThread.Create(FLog);


end;

procedure TFMain.btnStopClick(Sender: TObject);
var
  I: Integer;
begin
  for I := low(ft) to MAXTHREADS-1 do
  begin
    FT[i].SicherFreigeben(FT[i]);
  end;

end;
procedure TFMain.FormCreate(Sender: TObject);
begin
 //
 FLog:=TTestLog.Create(self);
 FLog.Parent:=self;
 FLog.Align:=alClient;

 //Hier ist mein aktueller Workaround:
 //Wenn True, darf erst was hinzugefügt werden, wenn Paint aufgerufen wurde
 //auf False setzen um die Windows Fehler zu sehen ;)
 FLog.WorkaroundActive:=true;

 btnStartClick(self);
end;

procedure TFMain.FormDestroy(Sender: TObject);
begin
 btnStopClick(self);
end;

end.

[TiGü]

Delphi-Quellcode:

procedure TTestLog.AddLog(const AMessage: string);
begin
  FListBox.Items.Add(AMessage);

  SendMessage(FListBox.Handle, LB_SETTOPINDEX, FListBox.Items.Count-1, 0);
  FListBox.Update;
  self.Update;
end;


procedure TTestLog.AddLogThreadSafe(const AMessage: string);
begin
  if TThread.CurrentThread.ThreadID = MainThreadID then
  begin
    AddLog(AMessage)
  end
  else
  begin
    TThread.Queue(nil,
      procedure
      begin
        AddLog(AMessage);
      end);
  end;
end;

Probiere mal so und rufe zum Loggen nur AddLogThreadSafe auf.

[4dk2]

Danke für die schnelle Antwort.
Klappt.
Aber, mich würde trotzdem noch interessieren, wann bei meiner Methode, die Komponente einsatzbereit wäre.

Z.b. wegen Abwärtskompatibilität (D7 usw).

[TiGü]

Na ja, der Ansatz ist halt schon etwas auf dünnen Eis gebaut.
Einfach mal das Forum nach dem Stichwörtern Mainthread, VCL und threadsafe abklappern, zum Beispiel hier:
http://www.delphipraxis.net/179429-v...read-save.html
http://www.delphipraxis.net/83472-th...l-zugriff.html

Für D7 kannste auch GetCurrentThreadId aus der Windows.pas nehmen.

[4dk2]

Zitat von TiGü:

Na ja, der Ansatz ist halt schon etwas auf dünnen Eis gebaut.
...
Für D7 kannste auch GetCurrentThreadId aus der Windows.pas nehmen.

Bei D7 gab es das Queing noch nicht.

Ich bin bei der Komponenten Programmierung einfach nicht tief genug drin

[4dk2]

Hab jetzt noch nen paar themen, und auch eine links dazu gelesen, und du hast recht es
ist einfach nur sinvoll wenn man es per:

Antwort: Queue oder Synchronize benutzen

macht,
für D7 geht das hier dann:
http://www.uweraabe.de/Blog/2011/01/...th-parameters/