Understanding Asynchronous Sockets

Discusses how asynchronous sockets (in Chilkat) are used for reading, writing, connecting, and accepting connections. The same code works for both SSL/TLS and non-SSL/TLS (unencrypted) sockets.

Download Chilkat Socket ActiveX

uses
    Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
    Dialogs, StdCtrls,
    CHILKATSOCKETLib_TLB,
    OleCtrls;

...

procedure TForm1.Button1Click(Sender: TObject);
var
socket: TChilkatSocket;
success: Integer;
useSsl: Integer;
maxWaitMillisec: Integer;
remoteHost: String;
remotePort: Integer;

begin
socket := TChilkatSocket.Create(Self);

success := socket.UnlockComponent('Anything for 30-day trial');
if (success <> 1) then
  begin
    ShowMessage(socket.LastErrorText);
    Exit;
  end;

useSsl := 0;
maxWaitMillisec := 20000;

//  The remote hostname may be an IP address, a domain name,
//  or "localhost".  You'll need to change this:

remoteHost := '123.123.88.88';
remotePort := 8125;

//  The meaning of "asynchronous" is that the socket operation, whether
//  it be a read, write, connect, or accept, happens in a background
//  thread and thus leaves your application free to do something
//  else while the socket operation is running.
// 
//  Note: If your application is simply going to initiate an asynchronous operation
//  and do nothing except wait for it to complete, then it may as
//  well use the synchronous socket methods -- there's no point in adding
//  complexity to your application if it's not necessary.  The meaning of "synchronous"
//  is that the method call (for reading, writing, connecting, accepting) does not
//  return until the socket operation is complete.
// 
//  All asynchronous socket operations follow these basic steps:
//  1) Initiate the asynchronous socket operation.  This starts a background thread
//  that does the work. The method called to initiate the asynchronous operation
//  returns immediately.
//  2) Wait until the operation is completed by periodically examining the
//  "Finished" property.  Each type of socket operation has it's own "Finished" property, such as AsyncReceiveFinished.
//  Once it becomes 1 or 0, you may check the "Success" property (see next step).
//  3) Once finished, you may check the "Success" property to see if the asynchronous operation
//  succeeded or failed.  Each type of socket operation has it's own "Success" property,
//  such as AsynchReceiveSuccess.
//  4) If it failed, the error information is available in the "Log" property, such as "AsyncReceiveLog".
//  5) If success, then the return data is available in another property (see below).

//  -------------------------------------------------------------------------
//  Asynchronous Socket Methods and Properties
//  -------------------------------------------------------------------------
// 
//  --------------------
//  Receiving Data:
//  --------------------
// 
//   Methods for initiating a background receive:
//      AsyncReceiveBytes
//      AsyncReceiveBytesN
//      AsyncReceiveString
//      AsyncReceiveToCRLF
//      AsyncReceiveUntilMatch
//   Properties:
//      AsyncReceiveFinished - Becomes 1 when completed.
//      AsyncReceiveSuccess - Set to 1 or 0 when finished.
//       AsyncReceiveLog - Error information if failed.
//      AsyncReceivedBytes - Data received if receiving binary data.
//       AsyncReceivedString -- Data received if receiving a string.
// 
//  --------------------
//  Sending Data:
//  --------------------
// 
//  Methods for initiating a background send:
//      AsyncSendBytes
//      AsyncSendString
//  Properties:
//      AsyncSendFinished - Becomes 1 when completed.
//      AsyncSendSuccess - Set to 1 or 0 when finished.
//       AsyncSendLog - Error information if failed.

//  --------------------
//  Making a TCP Connection:
//  --------------------
// 
//  Method for initiating a background connect:
//      AsyncConnectStart
//  Properties:
//      AsyncConnectFinished - Becomes 1 when completed.
//      AsyncConnectSuccess - Set to 1 or 0 when finished.
//       AsyncConnectLog - Error information if failed.

//  --------------------
//  Accepting an Incoming a TCP Connection:
//  --------------------
// 
//  Method for initiating a background accept:
//      AsyncAcceptStart
//  Properties:
//      AsyncAcceptFinished - Becomes 1 when completed.
//      AsyncAcceptSuccess - Set to 1 or 0 when finished.
//       AsyncAcceptLog - Error information if failed.
// 
//  ** After AsyncAcceptFinished becomes 1 *and* AsyncAcceptSuccess
//  is 1, the connected socket may be retrieved by calling AsyncAcceptSocket.

//  --------------------
//  DNS Lookup
//  --------------------
// 
//  Method for initiating a background DNS lookup:
//      AsyncDnsStart
//  Properties:
//      AsyncDnsFinished - Becomes 1 when completed.
//      AsyncDnsSuccess - Set to 1 or 0 when finished.
//       AsyncDnsLog - Error information if failed.
//       AsyncDnsResult - The IP address of the DNS lookup if successful.

//  The following code demonstrates connecting, sending, and receiving asynchronously.
//  NOTE: This example simply waits for each background operation
//  to complete.  In general, the whole point of doing something
//  asynchronously is so your application is free to do other things,
//  such as manage the user-interface.

//  Connect to the remote host asynchronously in a background thread.
success := socket.AsyncConnectStart(remoteHost,remotePort,useSsl,maxWaitMillisec);
if (success <> 1) then
  begin
    ShowMessage(socket.LastErrorText);
    Exit;
  end;

//  Wait for the socket to become connected...
while (socket.AsyncConnectFinished <> 1) do
  begin
    //  Sleep 1 second.
    socket.SleepMs(100);
  end;

//  Did the connect fail?
if (socket.AsyncConnectSuccess <> 1) then
  begin
    ShowMessage(socket.AsyncConnectLog);
    Exit;
  end;

//  Set maximum timeouts for reading an writing (in millisec)
socket.MaxReadIdleMs := 20000;
socket.MaxSendIdleMs := 20000;

//  Send a "Hello Server! -EOM-" message:
success := socket.AsyncSendString('Hello Server! -EOM-');
if (success <> 1) then
  begin
    ShowMessage(socket.LastErrorText);
    Exit;
  end;

//  Wait for the send to finish
while (socket.AsyncSendFinished <> 1) do
  begin
    //  Sleep 1 second.
    socket.SleepMs(100);
  end;

//  Did the send fail?
if (socket.AsyncSendSuccess <> 1) then
  begin
    ShowMessage(socket.AsyncSendLog);
    Exit;
  end;

//  The server (in this example) is going to send a "Hello Client! -EOM-"
//  message.  Begin reading asynchronously in a background thread:
success := socket.AsyncReceiveUntilMatch('-EOM-');
if (success <> 1) then
  begin
    ShowMessage(socket.LastErrorText);
    Exit;
  end;

//  Wait for the background read to finish
while (socket.AsyncReceiveFinished <> 1) do
  begin
    //  Sleep 1 second.
    socket.SleepMs(100);
  end;

//  Did the receive fail?
if (socket.AsyncReceiveSuccess <> 1) then
  begin
    ShowMessage(socket.AsyncReceiveLog);
    Exit;
  end;

//  Display the received message:
ShowMessage(socket.AsyncReceivedString);

//  Close the connection with the server
//  Wait a max of 20 seconds (20000 millsec)
socket.Close(20000);
end;