Asynchronous Paradigm

To Block or not to Block

Non-Blocking

Think of windows programming. It's event driven. Your application doesn't wait in a loop polling the status of a button until it is pressed, instead it gets notified about a button click; in other words an event is triggered. You simply place code to be executed in the event handler. When the user hits the button, the OnClick event is fired and your code is run. Very efficient. This functionality is called event-driven, non-blocking or asynchronous (async).

When you call an asynchronous method it will return immediately, regardless whether it has finished or not; an event handler will be called later when the method has finished. This also means that your application is capable of doing something else in the meanwhile, so the following pseudo code suitable for blocking internet components will NOT work with non-blocking ICS components:

Connect;
Send(Something); 

Connect will return immediately without even making sure it has finished successfully and the next line will be executed at once. Consequently, Send(Something) will fail because it's trying to send data even though there is no connection to the server established yet.

So we need to design our program a bit different. Just like the events of TButton, the ICS components provide many events allowing us to control program flow. After the event handler has been assigned we have to call the method, from then on we rely on events. So we just call Connect, and that's it:

procedure TForm1.MySendData;
begin    
    WSocket1.OnSessionConnected := WSocket1SessionConnected;
    WSocket1.Connect;
end;

Later, when the Connect method has finished, the OnSessionConnected event will fire. From within its event handler we can safely send data.

procedure TForm1.WSocket1SessionConnected(Sender: TObject; ErrCode: Word);
begin
    WSocket1.Send(Something);
end;

Very easy, isn't it?

The same principle applies when data is received: You never request to read data, you never wait until data is received completely, but simply assign the appropriate event handler to the OnDataAvailable event and your program gets notified whenever data is available.

procedure TForm1.WSocket1DataAvailable(Sender: TObject; ErrCode: Word);
var
    S : String;     
begin
    if ErrCode = 0 then begin
        S := WSocket1.ReceiveStr;
        if S = 'Hello'#13#10 then
            SendStr('Hi there'#13#10);
    end;             
end;

Note that OnDataAvailable will fire again if you do not receive all pending data in one go.

Blocking

Blocking or synchronous (sync) methods do NOT return until they have finished, so our first example would work:

Connect;
Send(Something);

Connect won't return until the connection to the server has been established or an error occured. While the program tries to connect it cannot do anything else, it blocks execution even though the Connect method may just sit there waiting for a server response. Blocking calls may even freeze the GUI unless you use multiple threads. ICS provides asynchronous as well as synchronous methods and components for most upper protocol implementations. Note that ICS does not freeze your GUI because even in synchronous mode, window messages are being processed.

Blocking vs. Non-Blocking

Due to the non-blocking nature of ICS it is very easy to handle hundreds of concurrent connections within a single thread.

Take the following pseudo code example to illustrate how to do this:

procedure TForm1.MySendData;
var
    I : Integer;    
begin    
    for I := 0 to List.Count -1 do
        TWSocket(List[I]).Connect;
end;

procedure TForm1.WSocket1SessionConnect(Sender: TObject; ErrCode: Word);
begin
    if ErrCode = 0 then
        TWSocket(Sender).Send(Something);
end; 

With blocking components, multiple concurrent connections are only possible if each connection is executed in its own thread context. But threads must be created, freed, synchronized or managed by so called thread pools. This all adds processing overhead, and does not necessarily help speed up your application's performance, as you can imagine.