Simplifying sockets & threading in VB.NET?

I am unsure of any specific examples that show you how to do what you are thinking of doing but I’m sure they are out there.

Here is a method I use for this type of app.

This would change somewhat if you were writing a UI type program but usually these types of app run as windows services. In either case it should work but the UI *could* get choppy under heavy load.

Your application starts with it’s initial thread. Open the socket with this thread and begin listening for new connections. This can be done like this:

Dim Listener as New Net.Sockets.TcpListener(Net.IPAddress.Any, ControlPort)

‘Now start a loop that watches for new connections:
While (ContinueListeningFlag = True)

      If Listener.Pending = True Then
            ‘create new client (see below)

            'we have a client waiting to talk to us
            Dim ClientSocket As Net.Sockets.TcpClient

            'accept the client
            ClientSocket = Listener.AcceptTcpClient

            Dim Client as new Client(ClientSocket)

            AllClients.add(Client)
      End if

      For each Client in AllClients
            If client.IsNotProcessing andalso client.NeedsProcessing then
                  Client.Process
            End if
      Next


      System.Threading.Thread.CurrentThread.Sleep(10)
End While


There are a number of things you’ll notice in this loop. First we only stay in the loop until we set the ContinueListeningFlag to false, which lets us jump out if needed. Inside the loop we first check for any pending connections and create new clients for them. A client is a class which at the minimum keeps a reference to the new connection. Then we check each client to see if there is processing to be done, doing this processing when necessary.

I believe this is most important because you DO NOT want to create a thread for each client for the life of the client. This will reduce your overall scalability because much of the time those client threads will just sit and do nothing.

How do you know if a client needs processing? And what do you do if it does? The client maintains it’s connection and using that it can see if there is any pending data waiting to be read, plus because it’s the client object, it will know if it has any data to send to the user of the client (it will know because you will have designed it that way). Assuming the client only listens for data coming in and then responds to that data, you could create a needsprocessing function like this:

Public function NeedsProcessing() as Boolean
      Return mTCPClient.GetStream.DataAvailable
End function

This will tell the caller there needs to be some action taken on the client.

Now how do you stick this processing on another thread? Create a method in the client object called Process, which takes one parameter of type object.

Then simply start the client on it’s merry way like this:
System.Threading.ThreadPool.QueueUserWorkItem(AddressOf Client.Process, Nothing)

This will tell the .net framework that you want to start a new thread and have this thread do the work of process.

When the process method ends, the thread will be returned to the pool for use later by someone else or some other client.

It’s important to keep the client.process method as short as possible because you want to tie up as few system resources as you can.

Notice the Client.IsNotProcessing property I also check when seeing if I should process a client. I set this property to false when I start the client.process method and set it to true when I end it. You COULD roll this into the NeedsProcessing procedure and I might even recommend doing that.

We skipped over a rather large topic which should be on the forefront of any threading discussion. That is thread synchronization. That is a complex topic, which I will refer you to another source for.

See the book: Programming Microsoft Visual Basic.net by Francesco Balena for an in-depth talk on threading and thread synchronization.

Hope this at least helps point you in the right direction.