Chat service application

This is still c# and sockets but my approach is different to yours.

I went with the concept of a "connectedCleint" which is similar in purpose to what you've called an account.

I have a class called ServerTerminal which is responsible for accepting and top level management of socket connections. In this i've got:

 public Dictionary<long, ConnectedClient> DictConnectedClients = new Dictionary<long, ConnectedClient>(); 

So this is my list of connected clients indexed by the sockethandle.

To accept connections i've got a routine:

public void StartListen(int port) { socketClosed = false; IPEndPoint ipLocal = new IPEndPoint(IPAddress.Any, port); listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); //bind to local IP Address... //if ip address is allready being used write to log try { listenSocket.Bind(ipLocal); } catch (Exception excpt) { // Deal with this.. write your own log code here ? socketClosed = true; return; } //start listening... listenSocket.Listen(100); // Max 100 connections for my app // create the call back for any client connections... listenSocket.BeginAccept(new AsyncCallback(OnClientConnection), null); } 

So when a client connects it then fires off:

private void OnClientConnection(IAsyncResult asyn) { if (socketClosed) { return; } try { Socket clientSocket = listenSocket.EndAccept(asyn); ConnectedClient connectedClient = new ConnectedClient(clientSocket, this, _ServerTerminalReceiveMode); //connectedClient.MessageReceived += OnMessageReceived; connectedClient.Disconnected += OnDisconnection; connectedClient.dbMessageReceived += OndbMessageReceived; connectedClient.ccSocketFaulted += ccSocketFaulted; connectedClient.StartListening(); long key = clientSocket.Handle.ToInt64(); if (DictConnectedClients.ContainsKey(connectedClient.SocketHandleInt64)) { // Already here - use your own error reporting.. } lock (DictConnectedClients) { DictConnectedClients[key] = connectedClient; } // create the call back for any client connections... listenSocket.BeginAccept(new AsyncCallback(OnClientConnection), null); } catch (ObjectDisposedException excpt) { // Your own code here.. } catch (Exception excpt) { // Your own code here... } } 

The crucial part of this for you is:

 // create the call back for any client connections... listenSocket.BeginAccept(new AsyncCallback(OnClientConnection), null); 

This sets up the serverterminal to receive new connections.

Edit: Cut down version of my connectedclient:

public class ConnectedClient { private Socket mySocket; private SocketIO mySocketIO; private long _mySocketHandleInt64 = 0; // These events are pass through; ConnectedClient offers them but really // they are from SocketIO public event TCPTerminal_ConnectDel Connected { add { mySocketIO.Connected += value; } remove { mySocketIO.Connected -= value; } } public event TCPTerminal_DisconnectDel Disconnected { add { mySocketIO.Disconnected += value; } remove { mySocketIO.Disconnected -= value; } } // Own Events public event TCPTerminal_TxMessagePublished TxMessageReceived; public delegate void SocketFaulted(ConnectedClient cc); public event SocketFaulted ccSocketFaulted; private void OnTxMessageReceived(Socket socket, TxMessage myTxMessage) { // process your message } private void OnMessageSent(int MessageNumber, int MessageType) { // successful send, do what you want.. } public ConnectedClient(Socket clientSocket, ServerTerminal ParentST) { Init(clientSocket, ParentST, ReceiveMode.Handler); } public ConnectedClient(Socket clientSocket, ServerTerminal ParentST, ReceiveMode RecMode) { Init(clientSocket, ParentST, RecMode); } private void Init(Socket clientSocket, ServerTerminal ParentST, ReceiveMode RecMode) { ParentServerTerminal = ParentST; _myReceiveMode = RecMode; _FirstConnected = DateTime.Now; mySocket = clientSocket; _mySocketHandleInt64 = mySocket.Handle.ToInt64(); mySocketIO = new SocketIO(clientSocket, RecMode); // Register for events mySocketIO.TxMessageReceived += OnTxMessageReceived; mySocketIO.MessageSent += OnMessageSent; mySocketIO.dbMessageReceived += OndbMessageReceived; } public void StartListening() { mySocketIO.StartReceiving(); } public void Close() { if (mySocketIO != null) { mySocketIO.Close(); mySocketIO = null; } try { mySocket.Close(); } catch { // We're closing.. don't worry about it } } public void SendMessage(int MessageNumber, int MessageType, string Message) { if (mySocket != null && mySocketIO != null) { try { mySocketIO.SendMessage(MessageNumber, MessageType, Message); } catch { // mySocketIO disposed inbetween check and call } } else { // Raise socket faulted event if (ccSocketFaulted != null) ccSocketFaulted(this); } } } 

}

Some useful links:

This is where I started: http://vadmyst.blogspot.com.au/2008/01/how-to-transfer-fixed-sized-data-with.html

http://vadmyst.blogspot.com.au/2008/03/part-2-how-to-transfer-fixed-sized-data.html

And..

C# Sockets and Multithreading

Cause a connected socket to accept new messages right after .BeginReceive?

http://nitoprograms.blogspot.com.au/2009/04/tcpip-net-sockets-faq.html

http://www.codeproject.com/Articles/83102/C-SocketAsyncEventArgs-High-Performance-Socket-Cod

I can't post my entire solution just now; there is a flaw in my server code I need to debug; plus there are parts which my employer may not want published. But i based my code on what Vadym had for variable length messages.