Lazarus Pascal

Understanding Async Function Return Values

See more Async Examples

Explains how to get the return value of the function called synchonously in the background thread. Lazarus Pascal

program ChilkatDemo;

// Demonstrates using the Chilkat Pascal wrapper via the C bridge DLL.
// Builds as a console application under Lazarus (FPC) or Delphi.

{$IFDEF FPC}
  {$MODE DELPHI}
{$ENDIF}
{$APPTYPE CONSOLE}

uses
  {$IFDEF UNIX}
  cthreads,
  {$ENDIF}
  SysUtils,
  CkDllLoader,
  Chilkat.Task,
  Chilkat.Socket;

// ---------------------------------------------------------------------------

procedure RunDemo;
var
  success: Boolean;
  sock: TSocket;
  task: TTask;
  count: Integer;
  s: string;
  connection: TSocket;
  acceptedConnection: TSocket;

begin
  success := False;

  //  Some Chilkat functions can be called asynchronously.
  //  If a function "Func" can be called asynchronously, there will be a corresponding "FuncAsync" function that returns a Task object.
  //  
  //  When Task.Run is called, the synchronous "Func" runs in a background thread.
  //  

  //  For Chilkat methods that return a status (True/False), get returned value by calling GetResultBool.
  //  For example..

  sock := TSocket.Create;

  //  --------------------------------------------------------------
  //  Synchronous call returning True/False
  success := sock.Connect('example.com',443,True,5000);

  //  --------------------------------------------------------------
  //  Asynchronous call
  task := sock.ConnectAsync('example.com',443,True,5000);
  //  ...
  task.Run();
  //  ...
  //  ...
  //  Get the status (True/False) value returned by the synchronous method called in the background thread.
  success := task.GetResultBool();

  //  --------------------------------------------------------------
  //  Synchronous call returning an integer
  count := sock.ReceiveCount();

  //  --------------------------------------------------------------
  //  Asynchronous call
  task := sock.ReceiveCountAsync();
  //  ...
  task.Run();
  //  ...
  //  ...
  //  Get the integer value returned by the synchronous method called in the background thread.
  count := task.GetResultInt();

  //  --------------------------------------------------------------
  //  Synchronous call returning an string
  s := sock.ReceiveString();

  //  --------------------------------------------------------------
  //  Asynchronous call
  task := sock.ReceiveStringAsync();
  //  ...
  task.Run();
  //  ...
  //  ...
  //  Get the string value returned by the synchronous method called in the background thread.
  s := task.GetResultString();

  //  --------------------------------------------------------------
  //  Synchronous call returning an object
  connection := sock.AcceptNextConnection(5000);

  //  --------------------------------------------------------------
  //  Asynchronous call
  task := sock.AcceptNextConnectionAsync();
  //  ...
  task.Run();
  //  ...
  //  ...
  //  Get the object returned by the synchronous method called in the background thread.
  //  We do this a little differently.  We create an new object of the same type,
  //  and then load it with the returned object (assuming it was not null).
  acceptedConnection := TSocket.Create;
  if (task.TaskSuccess = True) then
    begin
      success := acceptedConnection.LoadTaskResult(task);
    end;


  sock.Free;
  acceptedConnection.Free;

end;

// ---------------------------------------------------------------------------

begin

  try
    RunDemo;
  except
    on E: Exception do
      WriteLn('Unhandled exception: ', E.ClassName, ': ', E.Message);
  end;

  WriteLn;
  {$IFDEF MSWINDOWS}
  WriteLn('Press Enter to exit...');
  ReadLn;
  {$ENDIF}
end.