CODEWITHSUNDEEP
c#
Kyle Price
Kyle Price

Reputation: 1

Alternative to a bunch of while (true) loops when awaiting messages or client connections? (TcpClient C#)

I thought C# was an event-driven programming language.

This type of thing seems rather messy and inefficient to me:

tcpListener.Start();

while (true)
{
    TcpClient client = this.tcpListener.AcceptTcpClient();

    Thread clientThread = new Thread(new ParameterizedThreadStart(HandleClientCommunication));

    clientThread.Start(client);
}

I also have to do the same kind of thing when waiting for new messages to arrive. Obviously these functions are enclosed within a thread.

Is there not a better way to do this that doesn't involve infinite loops and wasted CPU cycles? Events? Notifications? Something? If not, is it bad practice to do a Thread.Sleep so it isn't processing as nearly as often?

Upvotes: 0

Views: 1527

Answers (2)

jgauffin
jgauffin

Reputation: 101130

There are actually three ways to handle IO operations for sockets. The first one is to use the blocking functions just as you do. They are usually used to handle a client socket since the client expects and answer directly most of the time (and therefore can use blocking reads)

For any other socket handlers I would recommend to use one of the two asynchronous (non-blocking) models.

The first model is the easiest one to use. And it's recognized by the Begin/End method names and the IAsyncResult return value from the Begin method. You pass a callback (function pointer) to the Begin method which will be invoked when something has happened. As an example take a look at BeginReceive.

The second asynchronous model is more like the windows IO model (IO Completion Ports) . It's also the newest model in .NET and should give you the best performance. As SocketAsyncEventArgs object is used to control the behavior (like which method to invoke when an operation completes). You also need to be aware of that an operation can be completed directly and that the callback method will not be invoked then. Read more about RecieveAsync.

Upvotes: 1

DeCaf
DeCaf

Reputation: 6086

There is absolutely nothing wrong with the method you posted. There are also no wasted CPU cycles like you mentioned. TcpClient.AcceptTcpClient() blocks the thread until a client connects to it, which means it does not take up any CPU cycles. So the only time the loop actually loops is when a client connects.

Of course you may want to use something other than while(true) if you want a way to exit the loop and stop listening for connections, but that's another topic. In short, this is a good way to accept connections and I don't see any purpose of having a Thread.Sleep anywhere in here.

Upvotes: 1

Related Questions