Hallo zusammen,

ich würde mal gerne eure Meinung zu den Frameworks s.o. hören:
DEB: DEB
TMessageManager: http://docwiki.embarcadero.com/Libra...MessageManager

Ok, DEB nutzt womöglich Attribute um Methoden zu binden, das ist schön und modern, aber was bringt mir
das ausser etwas weniger Zeilen zu schreiben.
Auch kann DEB den ThreadType für die Synchroisation vorgeben, das ist schon interessanter.

Die machen ja prinzipiell beide Event Messaging, wobei TMessageManager orginal in Delphi/Fmx integriert ist.

Warum sollte ich da so etwas wie DEB benutzen, evtl. weil performanter oder andere Vorteile ?

Ich nutze im Moment den TMessageManager, und frage mich ob es irgendeinen Sinn macht über DEB nachzudenken.

Rollo

Der wichtigste Vorteil ist die Möglichkeit die Nachrichten auch asynchron zu versenden.

Ein kurzer Blick in die Quellen lässt mich aber noch an der Qualität zweifeln
Da ist so einiges beim Thema Threading und Locking noch im Argen ... ist allerdings auch noch recht frisch das Projekt und schauen wir mal wie der weitere Reifeprozess vorangeht.

Interessant ist es auf jeden Fall

Hallo Sir Rufo,

dankesehr für deine Einschätzung.

So ähnlich sehe ich das auch, und würde nur damit anfangen wenn es einen echten Vorteil bietet.
Schliesslich schleppt man schon genug Ballast mit sich rum.
Dann werde ich erstmal bei TMessageManager bleiben, das funktioniert ja auch und ist Teil der System units.

Rollo

So kann man zumindest relativ leicht aus einen abgespaltenen Thread in den VCL-Mainthread senden:

zusammenfalten · markieren

Delphi-Quellcode:

unit HierKönnteDeinUnitNameStehen;

interface

uses
  System.SysUtils,
  System.Classes,
  System.Messaging;

type
  TMessageManagerHelper = class helper for TMessageManager
    procedure SendMessageToQueue(const Sender: TObject; AMessage: TMessage; ADispose: Boolean = True);
  end;

implementation

{ TMessageManagerHelper }

procedure TMessageManagerHelper.SendMessageToQueue(const Sender: TObject; AMessage: TMessage; ADispose: Boolean = True);
begin
  TThread.Queue(nil,
    procedure
    begin
      Self.SendMessage(Sender, AMessage, ADispose);
    end
    );
end;

end.

Und so geht es asynchron aus dem Hauptthread - auf Wunsch auch mit Verzögerung:

zusammenfalten · markieren

Delphi-Quellcode:

uses
  System.SysUtils,
  System.Classes,
  System.Messaging,
  System.Threading;

type
  TMessageManagerHelper = class helper for TMessageManager
    procedure SendMessageAsynch(const Sender: TObject; AMessage: TMessage; ADelayMS: Cardinal = 0; ADispose: Boolean = True); overload;
    procedure SendMessageAsynch(const Sender: TObject; AMessage: TMessage; ADispose: Boolean = True); overload;
  end;

procedure TMessageManagerHelper.SendMessageAsynch(const Sender: TObject; AMessage: TMessage; ADelayMS: Cardinal;
  ADispose: Boolean);
begin
  TTask.Run(
    procedure
    begin
      if ADelayMS > 0 then begin
        Sleep(ADelayMS);
      end;
      TThread.Queue(nil,
        Self.SendMessage(Sender, AMessage, ADelayMS);
    end);
end;

procedure TMessageManagerHelper.SendMessageAsynch(const Sender: TObject; AMessage: TMessage; ADispose: Boolean);
begin
  SendMessageAsynch(Sender, AMessage, 0, ADispose);
end;

@Uwe:

Das kompiliert bei mir aber nur, wenn ich den Self.SendMessage Aufruf in einer procedure verbastle:

zusammenfalten · markieren

Delphi-Quellcode:

procedure TMessageManagerHelper.SendMessageAsynch(const Sender: TObject; AMessage: TMessage; ADelayMS: Cardinal; ADispose: Boolean);
begin
  TTask.Run(
    procedure
    begin
      if ADelayMS > 0 then
      begin
        Sleep(ADelayMS);
      end;
      TThread.Queue(nil,
        procedure
        begin
          Self.SendMessage(Sender, AMessage, ADispose)
        end)
    end);
end;

Ansonsten ne schöne Idee mit der Verzögerung!