In a previous post I talked about the System.Net.Sockets enhancements in .NET 3.5, and if you haven't read it I suggest you do before tucking in to this as some of that code is important to understand what's happening here. Before I start, in essence this is just a result of my experimentation and while it seems it does a pretty good job, I'm not going to claim it's bullerproof or that it's a good example of how to write a socket server all it does is demonstrate the techniques of working with the new classes and methods.
The sample solution you can see on the right there contains three projects. FlawlessCode contains all the classes we'll need to build ourselves a socket server. TestLoadGenerator is a console application which generates load for us by connecting lots of sockets to our server and sending it random data. TestSocketServer is a small socket server implementation using the classes in FlawlessCode.
TcpSocketListener
We'll begin by looking at the FlawlessCode project and in particular, the TcpSocketListener. It should be fairly obvious from the name what this class is meant to achieve, it sits in a loop listening for socket connections and lets us know when one arrives. The public interface is very simple and looks like this:
public void Start();
public void Stop();
public event EventHandler<SocketEventArgs> SocketConnected;
The only thing we'll take a closer look at here is the internal loop which accepts the client sockets. Here you can see the first usage of the new SocketAsyncEventArgs and we're calling AcceptAsync, in our callback we check the SocketError property to see if we had any errors.
private void ListenForConnection(SocketAsyncEventArgs args)
{
args.AcceptSocket = null;
listenerSocket.InvokeAsyncMethod(
new SocketAsyncMethod(listenerSocket.AcceptAsync)
, SocketAccepted, args);
}
private void SocketAccepted(object sender, SocketAsyncEventArgs e)
{
SocketError error = e.SocketError;
if (e.SocketError == SocketError.OperationAborted)
return; //Server was stopped
if (e.SocketError == SocketError.Success)
{
Socket handler = e.AcceptSocket;
OnSocketConnected(handler);
}
lock (this)
{
ListenForConnection(e);
}
}
ServerConnection
Next we're going to take a look at the ServerConnection class, this class encapsulates the concept of a connected client. Depending on what you wanted to do with your server you may decide to extend this class, rewrite it or maybe completely replace it with something derived from NetworkStream. For our purposes today, this class when created will begin listening for data from the network, it has two public methods, one to disconnect the client and one to send data synchronously back to the client. ServerConnection also fires two callbacks, one when data is received and one when the client is disconnected. Here is a rundown of the interesting parts:
public void Disconnect()
{
lock (this)
{
CloseConnection(eventArgs);
}
}
public void SendData(Byte[] data, Int32 offset, Int32 count)
{
lock (this)
{
State state = eventArgs.UserToken as State;
Socket socket = state.socket;
if (socket.Connected)
socket.Send(data, offset, count, SocketFlags.None);
}
}
private void ListenForData(SocketAsyncEventArgs args)
{
lock (this)
{
Socket socket = (args.UserToken as State).socket;
if (socket.Connected)
{
socket.InvokeAsyncMethod(socket.ReceiveAsync,
ReceivedCompleted, args);
}
}
}
private void ReceivedCompleted(Object sender,
SocketAsyncEventArgs args)
{
if (args.BytesTransferred == 0)
{
CloseConnection(args); //Graceful disconnect
return;
}
if (args.SocketError != SocketError.Success)
{
CloseConnection(args); //NOT graceful disconnect
return;
}
State state = args.UserToken as State;
Byte[] data = new Byte[args.BytesTransferred];
Array.Copy(args.Buffer, args.Offset, data, 0, data.Length);
OnDataReceived(data, args.RemoteEndPoint as IPEndPoint,
state.dataReceived);
ListenForData(args);
}
private void CloseConnection(SocketAsyncEventArgs args)
{
State state = args.UserToken as State;
Socket socket = state.socket;
try
{
socket.Shutdown(SocketShutdown.Both);
}
catch { } // throws if client process has already closed
socket.Close();
socket = null;
args.Completed -= ReceivedCompleted; //MUST Remember This!
OnDisconnected(args, state.disconnectedCallback);
}
Taking it from the top, we can see the public Disconnect method, this simply calls our internal CloseConnection method which shuts down the socket and fires our disconnected callback. An interesting point to note here is that when this class is instanciated we subscribe to the SocketAsyncEventArgs.Completed event, when a client disconnects we need to remember to unhook this event because when we're reusing objects and pooling resources like this it's a bad idea to leave these references hanging around. Moving down we have the public SendData method, nothing interesting here really, just a standard synchrounous call. Next we get to the internal loop which listens for data from the client, notice how we check SocketAsyncEventArgs.BytesTransferred, if this is zero, the client has closed the connection and disconnected gracefully. We check the value of SocketError here also to make sure there was no error anywhere, after that we make a copy of the bytes we received and inform any interested parties we have new data.
BufferPool and SocketArgsPool
These two classes help us with pooling our resources and are not really very interesting, they're also almost identical to the MSDN examples so you can either look there or just check out the code.
BufferPool: http://msdn2.microsoft.com/en-us/library/bb517542.aspx
SocketArgsPool: http://msdn2.microsoft.com/en-us/library/bb551675.aspx
TestSocketServer
Now that we've sen to main functionality in the FlawlessCode project we're going to look at a simple socket server implementation using these classes.
TcpSocketListener socketListener = new TcpSocketListener(IPAddress.Any, 12345, 10);
socketListener.SocketConnected += socketListener_SocketConnected;
socketListener.Start();
Fairly straight forward, we fire up out listener on port 12345 and give the listening socket an allowed connection backlog of 10.
static void socketListener_SocketConnected(object sender, SocketEventArgs e)
{
SocketAsyncEventArgs args = socketArgsPool.CheckOut();
bufferManager.CheckOut(args);
ServerConnection connection = new ServerConnection(e.Socket, args,
new DataReceivedCallback(DataReceived),
new DisconnectedCallback(Disconnected));
}
When a client connects we get an SocketAsyncEventArgs and some free buffer space for our client and then we create an instance of ServerConnection. Note that we are passing delegates into the constructor, this is because the ServerConnection begins listening for data immediately and we have to have the callbacks hooked up before hand. If we let the call to the constructor complete and the we hooked to standard events we may have already missed the first batch of data!
static void DataReceived(ServerConnection sender, DataEventArgs e)
{
//Do whatever we want here...
}
static void Disconnected(ServerConnection sender, SocketAsyncEventArgs e)
{
bufferManager.CheckIn(e);
socketArgsPool.CheckIn(e);
}
Here we do whatever processing is necessary when a client sends us data. When a client disconnects we just check our buffer space and SocketAsyncEventArgs back into their respective pools to fight another day.
TestLoadGenerator
I'm not going to go into how the load generation works for now, the code is all very straight forward if you've managed to follow the post this far I would imagine. One thing to note is that if you want to test this code and open thousands of connections you need to tweak a registry setting or windows wont give you enough ports. You will need to add the DWORD MaxUserPort to HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters and give it a high enough value that windows won't run out of ports (reboot required, sorry)! Here is a quick examaple of how the load generation classes are used:
static void Main(
string[] args)
{
LoadGenerator generator = new LoadGenerator(15000);
generator.BytesPerDelivery = 2048;
generator.DeliveriesPerSecond = 2;
generator.SocketCount = 15000;
generator.SocketDelay = 5;
generator.SocketsPerDelivery = 3;
generator.Start(IPAddress.Parse("127.0.0.1"), 12345);
Console.ReadLine();
generator.Stop();
}
Pretty easy to use, right? We create an instance of the LoadGenerator class, telling it we'd like 15,000 connections maximum. Then we set some properties saying that we'd like each connected socket to deliver 2K of data twice per second. We'd like 15,000 sockets and we'd like them to connect 5ms apart and that we want on average 3% of sockets to send data in each delivery. Then we just aim and fire! Check it out:
When this was taken, the server executable was using 109MB or RAM and 1% CPU on my desktop machine so I think at 15,000 connections we've got some pretty damned good performance out of this thing! Obviously when we start implementing the server logic and actually processing each packet this will go up, but for a bare socket server, I'm pretty pleased.
Net35SocketServer.zip (24.77 kb)
