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

Dim socket As New ChilkatSocket

Dim success As Long
success = socket.UnlockComponent("Anything for 30-day trial")
If (success <> 1) Then
    MsgBox socket.LastErrorText
    Exit Sub
End If

Dim useSsl As Long
useSsl = 0
Dim maxWaitMillisec As Long
maxWaitMillisec = 20000

'  The remote hostname may be an IP address, a domain name,
'  or "localhost".  You'll need to change this:
Dim remoteHost As String
remoteHost = "123.123.88.88"
Dim remotePort As Long
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
    MsgBox socket.LastErrorText
    Exit Sub
End If

'  Wait for the socket to become connected...
Do While (socket.AsyncConnectFinished <> 1)
    '  Sleep 1 second.
    socket.SleepMs 100
Loop

'  Did the connect fail?
If (socket.AsyncConnectSuccess <> 1) Then
    MsgBox socket.AsyncConnectLog
    Exit Sub
End If

'  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
    MsgBox socket.LastErrorText
    Exit Sub
End If

'  Wait for the send to finish
Do While (socket.AsyncSendFinished <> 1)
    '  Sleep 1 second.
    socket.SleepMs 100
Loop

'  Did the send fail?
If (socket.AsyncSendSuccess <> 1) Then
    MsgBox socket.AsyncSendLog
    Exit Sub
End If

'  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
    MsgBox socket.LastErrorText
    Exit Sub
End If

'  Wait for the background read to finish
Do While (socket.AsyncReceiveFinished <> 1)
    '  Sleep 1 second.
    socket.SleepMs 100
Loop

'  Did the receive fail?
If (socket.AsyncReceiveSuccess <> 1) Then
    MsgBox socket.AsyncReceiveLog
    Exit Sub
End If

'  Display the received message:
MsgBox socket.AsyncReceivedString

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