Pascal (Lazarus/Delphi)

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. Pascal (Lazarus/Delphi)

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.