Wie schnell ist SendMessage?

[Carsten1234]

[Komische Frage, ich weiß :stupid:]

Hallo zusammen,

ein Konfigurationsprogramm hat ein Hauptformular, in das Unterformulare (ca. 20 Stück) eingebettet werden. Alle Unterformulare haben einen gemeinsamen Vorfahren und enthalten eine private Load- und Save-Routine, um die "unterformulareigenen" Daten zu laden bzw. zu speichern.

Soll nun vom Hauptformular aus gespeichert werden, schickt das Hauptformular zunächst an alle Unterformulare eine (Send-)Message, die jedes Unterformular dazu auffordert, seine persönlichen Daten (in ein unterformulareigenen Record) zu speichern. Anschließend speichert das Hauptformular das Hauptrecord, welches alle Unterrecords beinhaltet, auf HDD.
Nun habe ich Bedenken, dass SendMessage ggf. zu langsam sein könnte und noch nicht alle Unterformulare ihre persönlichen Daten gespeichert haben, bevor das Hauptformular beginnt, die Daten bzw. das Hauptrecord wegszuspeichern.
Daher überlege ich, entweder vor dem Speichern des Hauptrecords eine Delay einzulegen (zu unsicher) oder jede unterformulareigene Save-Routine als public zu deklarieren, um nicht die Message zu verschicken, sondern jede Save-Routine einzeln aufzurufen.

Meinungen dazu?

Dank vorab und Gruß, Carsten

[Bernhard Geyer]

Zitat:

Zitat von Carsten1234

... Daher überlege ich, entweder vor dem Speichern des Hauptrecords eine Delay einzulegen (zu unsicher) ...

Ist vollkommen unnötig. SendMessage wird sofort zu gestellt. Ein aynchronität bzw. ein "überholen" des Haupformulares ist nicht möglich. SendMessage ist praktisch fast mit einem Public-Methodenaufruf gleich zu setzen was ich auch empfehlen würde. Anders wäre es bei PostMessage. Dies wird in die MessageQueue eingestellt und "irgendwann" zugestellt wenn die Queue abgearbeitet ist.

[Carsten1234]

Hallo Bernhard,

Zitat:

Zitat von Bernhard Geyer

SendMessage ist praktisch fast mit einem Public-Methodenaufruf gleich zu setzen was ich auch empfehlen würde.

Du meinst, dass ich ungeachtet der Tatsache, dass das Hauptformular SendMessage nicht überholen kann, trotzdem die unterformulareigenen Save-Routinen public deklarieren und aufrufen sollte!?!?

Ach ja, sollten die Unterformlare die empfangene (Save-) Message noch quittieren oder ist das unnötig?

Gruß, Carsten

[Bernhard Geyer]

Zitat:

Zitat von Carsten1234

Du meinst, dass ich ungeachtet der Tatsache, dass das Hauptformular SendMessage nicht überholen kann, trotzdem die unterformulareigenen Save-Routinen public deklarieren und aufrufen sollte!?!?

Ja. Was sollte es bringen. Ein virtuelle Save-Methode in eine Basisklasse die überschrieben wird ist genauso gut.

Zitat:

Zitat von Carsten1234

Ach ja, sollten die Unterformlare die empfangene (Save-) Message noch quittieren oder ist das unnötig?

Ich würde eher ein CanSave-Methode definieren um ne Möglichkeit zu haben das Speichern generell zu verhindern.

[Carsten1234]

Zitat:

Zitat von Bernhard Geyer

Ja. Was sollte es bringen. Ein virtuelle Save-Methode in eine Basisklasse die überschrieben wird ist genauso gut.

Ich müsste alle Unterformulare dementsprechend anpassen => Fleißarbeit. :shock:

Danke für Deine Antwort und Gruß, Carsten

[SirThornberry]

ich würde es auch public machen. Wenn es alles im Programm verfügbar ist und auch aus anderen Modulen heraus das Speichern angestoßen werden können soll dann ist ein direkter Funktionsaufruf vorzuziehen.
Denn wenn du einer Variablen im eigenen Programm einen Wert zuweist gehst du doch auch nicht den Umweg über Sendmessage oder?

[HeinzJ]

Perform sollte noch fixer sein als SendMessage oder PostMessage
Sending Your Own Messages

[himitsu]

Perform könnte maximal programmintern schneller sein, da dort unter Umständen einige Umwege der VCL direkt abgekürzt werden können, aber programmextern geht es da auch wieder nur über SendMessage, wo es dann am Ende sogar langsamer sein müßte.

Und SendMessage wird nicht sofort ausgeführt.
Wenn gerade eine andere Message beim Empfänger in Bearbeitung ist, dann sollte dieses erst nach Beendigung dieser Bearbeitung ausgeführt werden ... wre auch blöd, weil man sonst ja auch noch alles Multithreadingfähig ausrüsten, wenn mehrere Messages (egal ob per SendMessage oder aus MessagePool via PostMessage) gleichzeitig ausgeführt werden würden :angel:

Aber:
- bei PostMessage wird die Nachricht an die MessageQueue angehängt und sozusagen erst nach allen anderen Nachrichten, welche schon im Pool drin sind, abgearbeitet (falls die MessageQueue nicht voll ist und die Nachricht nichtmal dort reingesellt wird)
- SendMessage kommt noch vorm Pool (MessageQueue) dran, aber vermutlich auch erst nachdem andere SendMessageSendMessages, welche vorher (seit Beginn der letzen Nachrichtenbearbeitung des Programm) losgeschickt/gestartet wurden.

[nicodex]

Zitat:

Zitat von himitsu

Und SendMessage wird nicht sofort ausgeführt.

Dann erkläre bitte, warum WM_BAR ankommt, während die Behandlung von WM_FOO noch nicht abgeschlossen ist:

Delphi-Quellcode:

unit Unit1;

interface

uses
  { Delphi Win }
  Windows,
  Messages,
  { Delphi RTL }
  SysUtils,
  Classes,
  { Delphi VCL }
  Controls,
  StdCtrls,
  Forms;

const
  WM_FOO = WM_USER + 42;
  WM_BAR = Succ(WM_FOO);

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
    FFoo: Integer;
    procedure WmFoo(var AMessage: TMessage); message WM_FOO;
    procedure WmBar(var AMessage: TMessage); message WM_BAR;
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  FFoo := 0;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  SendMessage(Handle, WM_FOO, 0, 0);
end;

procedure TForm1.WmFoo(var AMessage: TMessage);
begin
  InterlockedIncrement(FFoo);
  try
    SendMessage(Handle, WM_BAR, 0, 0);
  finally
    InterlockedDecrement(FFoo);
  end;
end;

procedure TForm1.WmBar(var AMessage: TMessage);
begin
  MessageBox(Handle, PChar('Foo: ' + IntToStr(FFoo)), 'Bar', MB_OK or
    MB_ICONINFORMATION);
end;

end.

ps: Deswegen sollte man auch mit Application.ProcessMessages() vorsichtig sein (bzw. sich über dessen Wirkung im Klaren sein).

[Luckie]

SendMessage wird direkt an die zugehörige WndProc des Fensters geschickt und kehrt zurück, wenn die Nachricht abgearbeitet wurde. Während PostMessage in die Nachrichtenschlange des Threads gestellt wird. Das heißt, SendMessage ist so schenll wie der zugehörige Thread die Nachricht abarbeiten kann. Und so lange ist der Thread, der die Nachricht verschickt, blockiert. also nach meinem bisherigen Verständniss.