(PowerShell) (Deprecated) Asynchronous Sockets

Notice: The functionality described here is deprecated and replaced by a newer model for asynchronous method calls. The newer model was introduced in Chilkat v9.5.0.52, and is identified by methods having names ending in “Async” which return a task object.

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.

Chilkat .NET Downloads Chilkat .NET Assemblies

Add-Type -Path "C:\chilkat\ChilkatDotNet47-9.5.0-x64\ChilkatDotNet47.dll"

# Notice: The functionality described here is deprecated and replaced 
# by a newer model for asynchronous method calls. The newer model was 
# introduced in Chilkat v9.5.0.52, and is identified by methods 
# having names ending in “Async” which return a task object.

# This example requires the Chilkat API to have been previously unlocked.
# See Global Unlock Sample for sample code.

$socket = New-Object Chilkat.Socket

$useSsl = $false
$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 $true or $false, 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 $true when completed.
#     AsyncReceiveSuccess - Set to $true or $false 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 $true when completed.
#     AsyncSendSuccess - Set to $true or $false when finished.
#      AsyncSendLog - Error information if failed.

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

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

# --------------------
# DNS Lookup
# --------------------
# 
# Method for initiating a background DNS lookup:
#     AsyncDnsStart
# Properties:
#     AsyncDnsFinished - Becomes $true when completed.
#     AsyncDnsSuccess - Set to $true or $false 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 -ne $true) {
    $($socket.LastErrorText)
    exit
}

# Wait for the socket to become connected...
while (($socket.AsyncConnectFinished -ne $true)) {
    # Sleep 1 second.
    $socket.SleepMs(100)
}

# Did the connect fail?
if ($socket.AsyncConnectSuccess -ne $true) {
    $($socket.AsyncConnectLog)
    exit
}

# 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 -ne $true) {
    $($socket.LastErrorText)
    exit
}

# Wait for the send to finish
while (($socket.AsyncSendFinished -ne $true)) {
    # Sleep 1 second.
    $socket.SleepMs(100)
}

# Did the send fail?
if ($socket.AsyncSendSuccess -ne $true) {
    $($socket.AsyncSendLog)
    exit
}

# 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 -ne $true) {
    $($socket.LastErrorText)
    exit
}

# Wait for the background read to finish
while (($socket.AsyncReceiveFinished -ne $true)) {
    # Sleep 1 second.
    $socket.SleepMs(100)
}

# Did the receive fail?
if ($socket.AsyncReceiveSuccess -ne $true) {
    $($socket.AsyncReceiveLog)
    exit
}

# Display the received message:
$($socket.AsyncReceivedString)

# Close the connection with the server
# Wait a max of 20 seconds (20000 millsec)
$success = $socket.Close(20000)