Async/Await in Delphi

Let’s assume you’ve inherited this pretty useless code.

procedure TForm125.Button1Click(Sender: TObject);
var
  button: TButton;
begin
  button := Sender as TButton;
  button.Caption := 'Working ...';
  button.Enabled := false;
  Sleep(5000);
  button.Enabled := true;
  button.Caption := 'Done!';
end;

Now, your boss says, you have to make it parallel so the user can start three copies of it. (You also have to add two new buttons to the form to start those instances but that’s easy to do.)

There are many ways to solve this problem, some more and some less complicated; I’d like to point out a simplest possible solution. But first, let’s take a detour into .NET waters …
.NET 4.5 introduced a heavy magical concept of ‘async’ and ‘await’ (learn more). In short, it allows you to write a code like this:

procedure TForm125.Button1Click(Sender: TObject); async;
var
  button: TButton;
begin
  button := Sender as TButton;
  button.Caption := 'Working ...';
  button.Enabled := false;
  await CreateTask(
    procedure begin
      Sleep(5000);
    end);
  button.Enabled := true;
  button.Caption := 'Done!';
end;

[Please note that this is not a supported syntax; that’s just an example of how the .NET syntax could look if Delphi would have supported it.]

The trick here is that ‘await’ doesn’t really wait. It relinquishes control back to the main loop which continues to process events etc. In other words – the rest of the program is running as usual. It may also call another asynchronous function and ‘await’ on it. Only when an asynchronous function returns (any of them, if there are more than one running), the control is returned to the point of the appropriate ‘await’ call and the code continues with the next line.

This is something that is possible to do only with the extensive support of the compiler and there’s absolutely no way to write an async/await clone in Delphi. But … there’s a simple trick which allows you to write the code in almost the same way. It uses OmniThreadLibrary’s Async construct and the magic of anonymous methods.

procedure TForm125.Button1Click(Sender: TObject);
var
  button: TButton;
begin
  button := Sender as TButton;
  button.Caption := 'Working ...';
  button.Enabled := false;
  Parallel.Async(
    procedure begin
      Sleep(5000);
    end,
    Parallel.TaskConfig.OnTerminate(
      procedure begin
        button.Enabled := true;
        button.Caption := 'Done!';
      end));
end;

Async executes its parameter (the delegate containing the Sleep call) in a background thread. When this background task is completed, it executes the second parameter (the OnTerminate delegate) in the main thread. While the background task is working, the main thread spins in its own message loop and runs the user interface – just as it would in the .NET case.

With some syntactical sugar, you can fake a very convincing .NET-like behavior.

type
  IAwait = interface
    procedure Await(proc: TProc);
  end;

  TAwait = class(TInterfacedObject, IAwait)
  strict private
    FAsync: TProc;
  public
    constructor Create(async: TProc);
    procedure Await(proc: TProc);
  end;

function Async(proc: TProc): IAwait;
begin
  Result := TAwait.Create(proc);
end;

{ TAwait }

constructor TAwait.Create(async: TProc);
begin
  inherited Create;
  FAsync := async;
end;

procedure TAwait.Await(proc: TProc);
begin
  Parallel.Async(FAsync, Parallel.TaskConfig.OnTerminated(
  procedure begin
    proc;
  end));
end;

{ TForm125 }

procedure TForm125.Button1Click(Sender: TObject);
var
  button: TButton;
begin
  button := Sender as TButton;
  button.Caption := 'Working ...';
  button.Enabled := false;
  Async(
    procedure begin
      Sleep(5000);
    end).
  Await(
    procedure begin
      button.Enabled := true;
      button.Caption := 'Done!';
    end);
end;

To test, put three buttons on a form and assign the Button1Click handler to all three. Click and enjoy.