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!

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 ...

zusammenfalten · markieren

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

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:

zusammenfalten · markieren

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;

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:

zusammenfalten · markieren

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>>;

Hallo Tigü,

ja das sieht super interessant aus, kannte ich noch gar nicht.
Mir war gar nicht aufgefallen das da schon Generics drin sind:

Zitat:

TMessage = class abstract;
TMessage<T> = class (TMessage)

markieren

Delphi-Quellcode:

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

Ist das jetzt eine Klasse, oder nicht ?

Wenn ja, wie wird Create und Destroy dabei aufgerufen ?
Aus besagten Gründen habe ich das als Record eingebaut.

Rollo