vb.net winforms tcp client-server tcpclient

TCP Client to Server communication

All I'm looking for is a simple TCPClient/Listner example on Windows Form VB.Net. I'm a newbie and Microsoft TCPClient/Listner class examples are not what I am looking for. All I am looking is for the TCPClient to send a message and for a TCPListener to get the message and to send a message back "I got your message" ?

A little help would be great. I have some codes, but is only to send message to server and not back from server to client.. Any help will be very appreciated..

Solution

TCP communication is stream-based, which means it doesn't handle any packets. Due to this, messages that you receive might be either partial or lumped together.

You could for example send:

Hello!

How are you?

But you might receive:

Hello!How are you?

or:

Hello!How ar

e you?

(or something similar)

To fix this you must apply something called "length-prefixing". Length-prefixing (or length prefixing) means that before you send a message, you put its length (amount of characters/bytes) in the beginning of it. By doing so, the endpoint will know exactly how many bytes to read for each message. Thus there will be no problems with messages being partial or lumped together.

This is not the most straightforward thing to do as a beginner, as to get it to work properly on both sides you have to structure your code just right. So I've created two classes that will take care of this for you. See the examples below on how to use them for simple text message-based communication.

Link to source: http://www.mydoomsite.com/sourcecodes/ExtendedTcpClient.zip

Link to C# source : http://www.mydoomsite.com/sourcecodes/ExtendedTcpClient%20CSharp.zip

EDIT (2019-11-08)

Some time ago I made an upgraded version of this with a bit better code structure and error handling. For those of you interested, the new code can be downloaded here (VB.NET only):

https://www.mydoomsite.com/sourcecodes/ExtendedTcpClient%202.0.zip

Example usage

Note that in those examples Client does not refer to the client side, but to the TcpClient.

Server side

First declare a new variable for ExtendedTcpClient, and be sure to include WithEvents in the declaration.
```
Dim WithEvents Client As ExtendedTcpClient
```

Then you will need a TcpListener and a Timer to check for incoming connections.

Dim Listener As New TcpListener("0.0.0.0", 5555) 'Listen for any connection on port 5555.
Dim WithEvents Tmr As New System.Windows.Forms.Timer

Then you need to subscribe to the timer's Tick event.
```
Private Sub Tmr_Tick(sender As System.Object, e As System.EventArgs) Handles Tmr.Tick

End Sub
```
In there you check for incoming connections via the Listener.Pending() method. When you are to accept a connection you first declare a new instance of the ExtendedTcpClient. The class requires to have a form as its owner, in this application Me is the current form.
Then you use the ExtendedTcpClient.SetNewClient() method with Listener.AcceptTcpClient() as its argument to apply the TcpClient from the listener. Put this code in the Tmr_Tick sub:
```
If Listener.Pending() = True Then
    Client = New ExtendedTcpClient(Me)
    Client.SetNewClient(Listener.AcceptTcpClient())
End If
```
Now the client and server are connected to each other.
Now you need to subscribe to the PacketReceived event of the client. Create a sub like so:
```
Private Sub Client_PacketReceived(sender As Object, e As ExtendedTcpClient.PacketReceivedEventArgs) Handles Client.PacketReceived

End Sub
```
All received data are presented in an array of bytes. In the PacketReceived sub you can output the received packet as text into a TextBox. Just check if the packet header is PlainText and then you can convert the received packets contents (which is an array of bytes, accessed via e.Packet.Contents) to a string and put it in the TextBox.
```
If e.Packet.Header = TcpMessagePacket.PacketHeader.PlainText Then
    TextBox1.AppendText("Message recieved: " & System.Text.Encoding.Default.GetString(e.Packet.Contents) & Environment.NewLine)
End If
```
System.Text.Encoding.Default.GetString() will convert a byte array to normal text.

In the PacketReceived sub you can also make it send "Message received" to the client.

Dim ResponsePacket As New TcpMessagePacket(System.Text.Encoding.Default.GetBytes("Message received."), TcpMessagePacket.PacketHeader.PlainText)
ResponsePacket.Send(Client.Client) 'Get the ExtendedTcpClient's underlying TcpClient.

Lastly, when closing the form you just need to disconnect the client.

Private Sub ServerWindow_FormClosing(sender As Object, e As System.Windows.Forms.FormClosingEventArgs) Handles Me.FormClosing
    If Client IsNot Nothing Then Client.Disconnect()
End Sub

And that's it for the server side.

Client side

For the client side you will do pretty much the same as the server side, though you won't be needing a TcpListener nor a Timer.
```
Dim WithEvents Client As New ExtendedTcpClient(Me) 'The current form as its owner.
```

Connect to the server via the IP and port you've given the listener.

Client.Connect("127.0.0.1", 5555) 'Connects to localhost (your computer) at port 5555.

Now if you want to send text to the server you'd do something like this (in for example a button):

Dim MessagePacket As New TcpMessagePacket(System.Text.Encoding.Default.GetBytes(TextBox2.Text), TcpMessagePacket.PacketHeader.PlainText)
MessagePacket.Send(Client.Client)

TextBox2 includes the text you want to send.

Lastly, you will need to subscribe to the PacketReceived event here too to check for responses from the server. In there you receive text just like the server does.

Private Sub Client_PacketReceived(sender As Object, e As ExtendedTcpClient.PacketReceivedEventArgs) Handles Client.PacketReceived
    If e.Packet.Header = TcpMessagePacket.PacketHeader.PlainText Then
        TextBox1.AppendText(System.Text.Encoding.Default.GetString(e.Packet.Contents) & Environment.NewLine) 'Prints for example "Message received." from the server.
    End If
End Sub

And now everything should be working!

Link to a complete example project (only client-to-server): http://www.mydoomsite.com/sourcecodes/TCP%20Messaging%20System.zip

Link to C# example: http://www.mydoomsite.com/sourcecodes/CSharp%20TCP%20Messaging%20System.zip

If you want to add more headers to the class (the headers indicate to you what kind of data each packet contains), open TcpMessagePacket.vb and add more values in the PacketHeader enum (located in the region called Constants).

Hope this helps!

Screenshot from the example project

(Click the image for larger resolution)