PowerShell

Bidirectional Sockets (TLS or non-TLS, simultaneous reading and writing a connection)

See more Socket/SSL/TLS Examples

This example demonstrates how to simultaneously read/write on a single socket connection. PowerShell

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

$success = $false

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

$tlsRead = New-Object Chilkat.Socket

# We'll just use an HTTPS server for this example...
$bUseTls = $true
$maxWaitMs = 5000
$success = $tlsRead.Connect("www.chilkatsoft.com",443,$bUseTls,$maxWaitMs)
if ($success -eq $false) {
    $($tlsRead.LastErrorText)
    exit
}

# Chilkat classes are thread-safe.  This means that only one method call can be active
# at a time for a given object instance.  It would seem that this would prevent the possibility
# to simultaneously read/write a given connection because it would require two method calls
# to be simultaneously active: one for reading and one for writing.
# 
# There's a trick to doing it...
# 
# The DupSocket method is provided to get a new object instance that shares the same socket
# connection.  This allows for the coarse-grained object-level thread safety to be maintained, 
# while finer-grained thread-safety mechanisms keep things kosher internally.

# One object will be used for reading, and the cloned socket is used for writing.
# It doesn't matter which --  you can use the cloned socket for reading or the original for writing.
# However.. if you try to read simultneously from both the original and cloned objects at the same
# time, then one will block until the other finishes.  (This is because of the finer-grained thread
# safety internally.)  The same is true if you try to write both socket objects simultaneously.

$tlsWrite = New-Object Chilkat.Socket
$success = $tlsRead.DupSocket($tlsWrite)
if ($success -eq $false) {
    $($tlsRead.LastErrorText)
    exit
}

# Let's start an async read on the socket.  Nothing will be arriving until we actually send the GET
# request and the server responds.  This will read until the end of the HTTP response header.
$task = $tlsRead.ReceiveUntilMatchAsync("`r`n`r`n")
$task.Run()

# Now send the request.  This should not block because the read is happening on the tlsRead object.
$httpGetReq = "GET / HTTP/1.1`r`nHost: www.chilkatsoft.com`r`n`r`n"
$success = $tlsWrite.SendString($httpGetReq)
# Assuming success for the example...

# Wait for the read task to finish.
# The $true/$false returned by Wait applies to the Wait method call, not the task.
$maxWaitMs = 5000
$success = $task.Wait($maxWaitMs)
if (!$success -or ($task.StatusInt -ne 7) -or ($task.TaskSuccess -ne $true)) {
    if (!$success) {
        # The task.LastErrorText applies to the Wait method call.
        $($task.LastErrorText)
    }
    else {
        # The ResultErrorText applies to the underlying task method call (i.e. the Connect)
        $($task.Status)
        $($task.ResultErrorText)
    }

    exit
}

# Examine the received HTTP response header:
$("HTTP response header:")
$($task.GetResultString())

# We should get a response that looks like this:
# 	HTTP response header:
# 	HTTP/1.1 200 OK
# 	Cache-Control: private
# 	Content-Length: 7477
# 	Content-Type: text/html
# 	Server: Microsoft-IIS/8.5
# 	Set-Cookie: ASPSESSIONIDSWDSTRTQ=BBNMIKGCHFJNILFFPLDIOGDE; secure; path=/
# 	X-Powered-By: ASP.NET
# 	X-Powered-By-Plesk: PleskWin
# 	Date: Thu, 06 Apr 2017 12:03:30 GMT

# Forget about the remainder of the HTTP response... The example was only to demonstrate
# simultaneous reading/writing..
$maxWaitMs = 20
$tlsRead.Close($maxWaitMs)