DEB DelphiEventBus vs. System.Messaging.TMessageManager

[Sir Rufo]

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

[Rollo62]

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

[TiGü]

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

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.

[Uwe Raabe]

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

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;

[TiGü]

@Uwe:

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

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!

[Rollo62]

Dankesehr für die interessanten Vorschläge.

Ich habe mal die Frage ob man Sleep() benutzen sollte, ich meine das verwendet auf manchen Platformen ntern
Applications.ProcessMessages.
Wäre nicht ein Timer oder WaitFor sicherer ?

Ich hatte versucht mir das mit Generics in eine abgeleitete Klasse zu basteln,
damit ich noch spezifisches Payload als Parameter und Feedback als Result-Wert mit übergeben kann.

Damit kann ich dann auch anonyme Prozeduren benutzen.

Das ist zwar noch etwas unsauber und unübersichtlich, weil viel TestCode suboptimal drin ist, aber funktioniert gut und zuverlässig.

Sieht ungefähr so aus, geht sicher einfacher, und ich muss das mal aufräumen wenn Zeit ist ...

Delphi-Quellcode:

// Definiert eine universelle Message-Ableitung, mit PAyload und Feedback
type
  TMsgLink<T1, T2> = class(TMessage)
  private
    FPayload  : T1;
    FFeedback : T2;

  protected

    constructor Create(const Payload : T1; const CbFkt : T2); overload;

  public

    procedure   SendToSubscriber(const Sender : TObject); //(xVal : T1);

    property Payload  : T1 read FPayload   write FPayload;
    property Feedback : T2 read FFeedback  write FFeedback;
  end;



// Definiert ein Boolean Callback, z.B. als Handled True/False
type
  TMsgFeedback_Boolean = TMsgFeedback<Boolean>;


// Definiert einen Parameter Record als PAyload für SendMEssage
type
  TMsgPayload = record
    public
      FCmd    : Integer;
      FCmdSub : Integer;
      FText   : String;

      procedure Setup(const iCmd, iCmdSub : Integer; sTxt: String);

    //procedure SetText(const sTxt : String);

    public

      property Cmd     : Integer read FCmd    write FCmd;
      property CmdSub  : Integer read FCmdSub write FCmdSub;
      property Text    : String  read FText   write FText;

  end;

// Baut alles zusammen zu einer einfachen MskLink Klasse
type
  TMsgLink_Cmd_Base  = class (TMsgLink<TMsgPayload, TMsgFeedback_Boolean>)
                        constructor Create(const iCmd, iCmdSub : Integer;
                                           const strTxt : String;
                                           const fktAsw : TProc<TObject, Boolean>
                                          ); overload;

                        constructor SendMessage(const ACmp   : TObject;
                                                const iCmd : Integer; iCmdSub : Integer = 0; const sTxt : String = '';
                                                const fktAsw : TProc<TObject, Boolean> = nil;
                                                bQueue       : Boolean = True
                                               ); overload;

                     end;


// So kann ich verschiedene, speziele MsgLinks aufbauen, für verschiedene Aufgaben

Rollo

[TiGü]

Zitat von Rollo62:

Ich hatte versucht mir das mit Generics in eine abgeleitete Klasse zu basteln,
damit ich noch spezifisches Payload als Parameter und Feedback als Result-Wert mit übergeben kann.

Du kannst auch sowas machen:

Delphi-Quellcode:

  TMyMessageContainer = class
  public
    Text: string;
    Number: Integer;
  end;

  TMyGenericMessage = System.Messaging.TMessage<TMyMessageContainer>;

  // oder noch mehr generisch:

  TMyGenericMessageContainer<T,K> = class
  public
    Prop1: T;
    Prop2: K;
  end;

  TMyMegaGenericMessage = System.Messaging.TMessage<TMyGenericMessageContainer<string, Integer>>;

[Uwe Raabe]

Zitat von TiGü:

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

Na klar! Das kommt, wenn man nach Copy-Paste das Compile vergisst...

Im Original ist das noch etwas allgemeiner gehalten:

Delphi-Quellcode:

procedure Postpone(AProc: TThreadProcedure; ADelayMS: Cardinal = 0);
begin
  TTask.Run(
    procedure
    begin
      if ADelayMS > 0 then begin
        Sleep(ADelayMS);
      end;
      TThread.Queue(nil, AProc);
    end);
end;

procedure Postpone(AProc: TThreadMethod; ADelayMS: Cardinal = 0);
begin
  TTask.Run(
    procedure
    begin
      if ADelayMS > 0 then begin
        Sleep(ADelayMS);
      end;
      TThread.Queue(nil, AProc);
    end);
end;