WriteAsync Method (TcpBase)

Visual Basic
C#
Managed Extensions for C++
C++/CLI

'Declaration
 
Public Sub WriteAsync( _
   ByVal buffer() As Byte, _
   ByVal offset As Integer, _
   ByVal count As Integer, _
   ByVal callback As TcpAsyncCallback, _
   ByVal state As Object _
)

'Usage
 
Dim instance As TcpBase
Dim buffer() As Byte
Dim offset As Integer
Dim count As Integer
Dim callback As TcpAsyncCallback
Dim state As Object
 
instance.WriteAsync(buffer, offset, count, callback, state)

public void WriteAsync( 
   byte[] buffer,
   int offset,
   int count,
   TcpAsyncCallback callback,
   object state
)

public: void WriteAsync( 
   byte[]* buffer,
   int offset,
   int count,
   TcpAsyncCallback* callback,
   Object* state
)

public:
void WriteAsync( 
   array<byte>^ buffer,
   int offset,
   int count,
   TcpAsyncCallback^ callback,
   Object^ state
)

Parameters

buffer: The byte array containing data to be written.
offset: The position in the buffer to start writing data from.
count: The number of bytes to write.
callback: A TcpAsyncCallback delegate referencing the method to invoke on an IO completion thread when the operation completes.
state: Object to pass into the callback method when the operation completes; can be null.

The TCP component is typically used by making blocking calls on a worker (non-UI) thread. This technique keeps development simple as there is no need for saving state information, but requires a dedicated thread for each connection. If a dedicated worker thread for each socket is not scalable enough, such as in server applications, developers can use Async methods which utilize IO completion ports. Async methods do not require a dedicated worker thread for each connection, and the specified callback is invoked on an IO completion thread when the operation completes. This is the best way to create a scalable, high-performance server.

The following example demonstrates an echo server using asynchronous read and write methods that utilize IO completion ports.

C#

private void button1_Click(object sender, EventArgs e)
{
    //Start the echo server on port 7
    server1.Start(server1_NewConnection, 7, null);
}

private void server1_NewConnection(Tcp client, object state)
{
    //Read first data sent by client
    byte[] buffer = new byte[1024];
    client.ReadAsync(buffer, 0, buffer.Length, client_ReadAsyncCompleted, null);
}

private void client_ReadAsyncCompleted(TcpBase client, Data data, Exception ex, object state)
{
    //Echo data received back to client.
    //Data is null if client is not connected.
    if (data != null)
        client.WriteAsync(data.Buffer, data.Offset, data.Count, client_WriteAsyncCompleted, null);
}

private void client_WriteAsyncCompleted(TcpBase client, Data data, Exception ex, object state)
{
    //Read for more data.
    client.ReadAsync(data.Buffer, 0, data.Buffer.Length, client_ReadAsyncCompleted, null);
}

Visual Basic

Private Sub button1_Click(ByVal sender As Object, ByVal e As EventArgs)
    'Start the echo server on port 7
    server1.Start(AddressOf server1_NewConnection, 7, Nothing)
End Sub

Private Sub server1_NewConnection(ByVal client As Tcp, ByVal state As Object)
    'Read first data sent by client
    Dim buffer(1023) As Byte
    client.ReadAsync(buffer, 0, buffer.Length, AddressOf client_ReadAsyncCompleted, Nothing)
End Sub

Private Sub client_ReadAsyncCompleted(ByVal client As TcpBase, ByVal data As Data, ByVal ex As Exception, ByVal state As Object)
    'Echo data received back to client.
    'Data is null if client is not connected.
    If data IsNot Nothing Then
        client.WriteAsync(data.Buffer, data.Offset, data.Count, AddressOf client_WriteAsyncCompleted, Nothing)
    End If
End Sub

Private Sub client_WriteAsyncCompleted(ByVal client As TcpBase, ByVal data As Data, ByVal ex As Exception, ByVal state As Object)
    'Read for more data.
    client.ReadAsync(data.Buffer, 0, data.Buffer.Length, AddressOf client_ReadAsyncCompleted, Nothing)
End Sub

Reference

TcpBase Class
TcpBase Members