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 event OnClick is fired and your code is run. Very efficient, this is called event-driven or 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 to do something else in the meanwhile so the following pseudo code suitable for blocking internet components would NOT work with non-blocking ICS components:

Connect
Send(Something) 

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

So we need to design your 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, that's it:

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

Later when method Connect has finished event OnSessionConnected will fire. From within its event handler you 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 event OnDataAvailable and your program gets notified as long as 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 sample 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 method connect 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.

I give you a pseudo example:

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 doesn't speed up things as you can imagine.