DEB DelphiEventBus vs. System.Messaging.TMessageManager
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 |
AW: DEB DelphiEventBus vs. System.Messaging.TMessageManager
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 :stupid: 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 |
AW: DEB DelphiEventBus vs. System.Messaging.TMessageManager
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 |
AW: DEB DelphiEventBus vs. System.Messaging.TMessageManager
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. |
AW: DEB DelphiEventBus vs. System.Messaging.TMessageManager
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; |
AW: DEB DelphiEventBus vs. System.Messaging.TMessageManager
@Uwe:
Das kompiliert bei mir aber nur, wenn ich den Self.SendMessage Aufruf in einer procedure verbastle:
Delphi-Quellcode:
Ansonsten ne schöne Idee mit der Verzögerung! :thumb:
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; |
AW: DEB DelphiEventBus vs. System.Messaging.TMessageManager
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:
Rollo
// 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 |
AW: DEB DelphiEventBus vs. System.Messaging.TMessageManager
Zitat:
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; |
AW: DEB DelphiEventBus vs. System.Messaging.TMessageManager
Zitat:
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>>; |
AW: DEB DelphiEventBus vs. System.Messaging.TMessageManager
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:
Delphi-Quellcode:
Ist das jetzt eine Klasse, oder nicht ?
TMyMessageContainer = class
public Text: string; Number: Integer; end; Wenn ja, wie wird Create und Destroy dabei aufgerufen ? Aus besagten Gründen habe ich das als Record eingebaut. Rollo |
Alle Zeitangaben in WEZ +1. Es ist jetzt 07:15 Uhr. |
Powered by vBulletin® Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz