i dati di invio stringa a partire da fili a forma principale

Question

In Dephi, creo un filo, come questo, che invierà un messaggio al modulo principale di tanto in tanto

Procedure TMyThread.SendLog(I: Integer); 
Var 
    Log: array[0..255] of Char; 
Begin 
    strcopy(@Log,PChar('Log: current stag is ' + IntToStr(I))); 
    PostMessage(Form1.Handle,WM_UPDATEDATA,Integer(PChar(@Log)),0); 
End; 

procedure TMyThread.Execute; 
var 
    I: Integer; 
begin 
    for I := 0 to 1024 * 65536 do 
    begin 
    if (I mod 65536) == 0 then 
    begin 
     SendLog(I); 
    End; 
    End; 
end; 

dove WM_UPDATEDATA è un messaggio personalizzato, definito di seguito:

const 
    WM_UPDATEDATA = WM_USER + 100; 

E in forma principale, lo farà come segue per aggiornare l'elenco:

procedure TForm1.WMUpdateData(var msg : TMessage); 
begin 
    List1.Items.Add(PChar(msg.WParam)); 
end; 

Tuttavia, come il registro la stringa inviata al modulo principale è una variabile locale, che verrà distrutta dopo aver chiamato SendLog. Mentre TForm1.WMUpdateData elabora il messaggio in modo asincrono, è possibile che quando viene richiamato, la stringa Log sia già stata distrutta. Come risolvere questo problema?

Penso che forse posso allocare lo spazio di stringa in uno spazio di sistema globale e quindi passarlo al messaggio, quindi dopo TForm1.WMUpdateData elabora il messaggio, esso può distruggere lo spazio di stringa nello spazio globale. È una soluzione praticabile? Come implementarlo?

Grazie

Answer 1

Utilizzare SendMessage().

PostMessage() elaborerà il messaggio in modo asincrono, in pratica inserisce nella coda messaggi di destinazione e restituisce immediatamente. Nel momento in cui il codice del gestore accede ai dati inviati in wparam/lparam, il chiamante ha già liberato la stringa.

Al contrario, SendMessage() ignora la coda messaggi e chiama direttamente la finestra proc (in modo sincrono). Nel momento in cui SendMessage() restituisce, è sicuro liberare la stringa.

Answer 2

Oltre al fatto che si sta postando una variabile locale, la proprietà TWinControl.Handle non è thread-safe. Dovresti invece utilizzare la proprietà TApplication.Handle oppure utilizzare AllocateHWnd() per creare la tua finestra.

È necessario allocare dinamicamente la stringa nell'heap, postare il puntatore nel thread principale e quindi liberare la memoria quando si è terminato di utilizzarlo.

Ad esempio:

procedure TForm1.FormCreate(Sender: TObject); 
begin 
    Application.OnMessage := AppMessage; 
    // or use a TApplicationEvents component... 
end; 

procedure TForm1.FormDestroy(Sender: TObject); 
begin 
    Application.OnMessage := nil; 
end; 

procedure TForm1.AppMessage(var Msg: TMsg; var Handled: Boolean); 
var 
    S: PString; 
begin 
    if Msg.Message = WM_UPDATEDATA then 
    begin 
    S := PString(msg.LParam); 
    try 
     List1.Items.Add(S^); 
    finally 
     Dispose(S); 
    end; 
    Handled := True; 
    end; 
end; 

procedure TMyThread.SendLog(I: Integer); 
var 
    Log: PString; 
begin 
    New(Log); 
    Log^ := 'Log: current stag is ' + IntToStr(I); 
    if not PostMessage(Application.Handle, WM_UPDATEDATA, 0, LPARAM(Log)) then 
    Dispose(Log); 
end; 

alternativa:

var 
    hLogWnd: HWND = 0; 

procedure TForm1.FormCreate(Sender: TObject); 
begin 
    hLogWnd := AllocateHWnd(LogWndProc); 
end; 

procedure TForm1.FormDestroy(Sender: TObject); 
begin 
    if hLogWnd <> 0 then 
    DeallocateHWnd(hLogWnd); 
end; 

procedure TForm1.LogWndProc(var Message: TMessage); 
var 
    S: PString; 
begin 
    if Message.Msg = WM_UPDATEDATA then 
    begin 
    S := PString(msg.LParam); 
    try 
     List1.Items.Add(S^); 
    finally 
     Dispose(S); 
    end; 
    end else 
    Message.Result := DefWindowProc(hLogWnd, Message.Msg, Message.WParam, Message.LParam); 
end; 

procedure TMyThread.SendLog(I: Integer); 
var 
    Log: PString; 
begin 
    New(Log); 
    Log^ := 'Log: current stag is ' + IntToStr(I); 
    if not PostMessage(hLogWnd, WM_UPDATEDATA, 0, LPARAM(Log)) then 
    Dispose(Log); 
end; 

Answer 3

Se si dispone della versione D2009 o successiva, esiste un altro modo per inviare messaggi al modulo principale. TThread.Queue è una chiamata asincrona da un thread, in cui è possibile eseguire un metodo o una procedura nel thread principale.

Il vantaggio è che il frame per impostare il passaggio dei messaggi è meno complesso. Basta passare il metodo di callback durante la creazione del thread. Nessuna maniglia e nessuna gestione esplicita dell'assegnazione/deallocazione di stringhe.

Type 
    TMyCallback = procedure(const s : String) of object; 

    TMyThread = class(TThread) 
    private 
     FCallback : TMyCallback; 
     procedure Execute; override; 
     procedure SendLog(I: Integer); 
    public 
     constructor Create(aCallback : TMyCallback); 
    end; 

constructor TMyThread.Create(aCallback: TMyCallback); 
begin 
    inherited Create(false); 
    FCallback := aCallback; 
end; 

procedure TMyThread.SendLog(I: Integer); 
begin 
    if not Assigned(FCallback) then 
    Exit; 
    Self.Queue( // Executed later in the main thread 
    procedure 
    begin 
     FCallback('Log: current stag is ' + IntToStr(I)); 
    end 
); 
end; 

procedure TMyThread.Execute; 
var 
    I: Integer; 
begin 
    for I := 0 to 1024 * 65536 do 
    begin 
    if ((I mod 65536) = 0) then 
    begin 
     SendLog(I); 
    End; 
    End; 
end; 

---

procedure TMyForm.TheCallback(const msg : String); 
begin 
    // Show msg 
end; 

procedure TMyForm.StartBackgroundTask(Sender : TObject); 
begin 
    ... 
    FMyThread := TMyThread.Create(TheCallback); 
    ... 
end;