System.Messaging.TMessageManager Asynchron?

[QuickAndDirty]

Funktioniert
System.Messaging.TMessageManager.SendMessage
Asynchron?

Ja ich hätte es auch ausprobiern können, aber ich kann das auf IOS nicht kurzfristig testen und ich muss wissen ob es Auf Win32, Android und IOS asnychron läuft!
Bzw.
Wenn nicht. gibt es ne andere Möglichkeit Asnychron zu Messagen ohne die Lösung von https://francois-piette.blogspot.de/...ndows-and.html
oder @Uwe Raabe zu benutzern?

Ja ich habe im Moment ne "eigene" "Lösung" im Einsatz...mir geht es vor allem um das asynchrone ausfühen von code.

In diesem zusammen hang.
Wieso hat Application.Processmessages einen Effekt in Android Apps? Gibt es die normale Message queue in Android apps?

[TiGü]

1) Nein.
2) Diverse Task- und Threadlösungen die in den gewünschten Threadkontext synchronisieren.

[TiGü]

Delphi-Quellcode:

unit System.Messaging.Extended;

interface

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

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

implementation

{ TMessageManagerHelper }

procedure TMessageManagerHelper.SendMessageAsync(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;

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

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.

[QuickAndDirty]

Ja So ein ähnliches System benutze ich bereits. Nur eben nicht für Messages sondern für TThreadMethods.

Delphi-Quellcode:

Procedure QueueMethod(aThreadMethod:TThreadMethod; QueueType:TQueueType=qtNone; Sender:TObject = nil );
implementation

type

  TQThread = Class(TThread)
  Public
    ThreadMethod:TThreadMethod;
    Procedure Execute;Override;
  end;


Procedure QueueMethod(aThreadMethod:TThreadMethod; QueueType:TQueueType=qtNone; Sender:TObject = nil );
var aThread:TQThread;
Begin
  case QueueType of
    qtNone: aThreadMethod; //direkt ausführen
    qtThread,qtIdle:
    Begin//Vom CPU Scheduler verzögern lassen
      if (MainThreadID = TThread.Current.ThreadID) then
      Begin
        aThread := TQThread.Create(true);
        aThread.FreeOnTerminate := True;
        aThread.ThreadMethod := aThreadMethod;
        aThread.Resume;
      end
      else
      Begin
        {$o-}
        TThread.ForceQueue(nil,aThreadMethod);
        {$o+}
      End;
    End;
  end;
End;


{ TQThread }
procedure TQThread.Execute;
begin
  {$o-}
  TThread.ForceQueue(nil,ThreadMethod);
  {$o+}
end;

[himitsu]

Wozu der Thread, wo doch ForceQueue "richtig" arbeitet?

Damals beim Queue war es ja so, dass es im Hauptthread aufgerufen sofort ausgeführt wurde, anstatt später.

[QuickAndDirty]

Zitat von himitsu:

Wozu der Thread, wo doch ForceQueue "richtig" arbeitet?

Damals beim Queue war es ja so, dass es im Hauptthread aufgerufen sofort ausgeführt wurde, anstatt später.

Evolution. Es war vormals tatsächlich nur Queue. Ich hab es dann auf ForceQueue umgesetzt ohne alles noch mal zu durch denken.

Tatsächlich würde das hier ausreichen?

Delphi-Quellcode:

Procedure QueueMethod(aThreadMethod:TThreadMethod; QueueType:TQueueType=qtNone);
implementation


Procedure QueueMethod(aThreadMethod:TThreadMethod; QueueType:TQueueType=qtNone);
var aThread:TQThread;
Begin
  case QueueType of
    qtNone: aThreadMethod; //direkt ausführen
    qtThread,qtIdle:
    Begin//Vom CPU Scheduler verzögern lassen
      {$o-}
      TThread.ForceQueue(nil,aThreadMethod);
      {$o+}
    End;
  end;
End;

bzw.
Könnt man auch direkt

Delphi-Quellcode:

{$o-}
  TThread.ForceQueue(nil,DoCloseFormAndOpenNextForm);
{$o+}

machen ?

[QuickAndDirty]

mal den anktuellen stand dokumentieren

Delphi-Quellcode:

Procedure QueueMethod(aThreadMethod:TThreadMethod);
Begin
      // Abgeschaut aus UNIT FMX.FORMS
      // procedure ReleaseForm(const AForm: TCommonCustomForm);
      // Wir müssen das immer so machen wie die das dort auch machen.
      // Unter der Annahme dass die FMX Bibliotheken fehlerfrei sind....

      {$IFDEF ANDRODID}
      TThread.CreateAnonymousThread(
        Procedure
        Begin
          TThread.CurrentThread.Queue(nil,AthreadMethod);
        end;
      );
      {$ELSE}
       TThread.CurrentThread.ForceQueue(nil,aThreadMethod);
      {$ENDIF}
end;

Das ist die Lösung mit der ich Momentan glücklich bin.
Man darf nur Appplication.Processmessages möglichst nirgends benutzen...Weil die Threadsynchronisation an der Messagequeue hängt.