Scalable TCP/IP Server Design Pattern

When designing a scalable TCP/IP server that requires long-running connections, it's crucial to consider the most efficient network architecture. Asynchronous sockets are a recommended approach due to their ability to handle multiple clients simultaneously without consuming excessive resources.

Network Architecture

• Server:

  • Start a service with at least one thread to handle incoming connections.
  • Implement asynchronous sockets using the BeginReceive and EndReceive methods.
  • Create a class to manage client connections, including a list to hold references to active clients.
  • Use the BeginAccept method on the server socket to listen for incoming connections and call the AcceptCallback when a connection is established.

• Client:

  • Connect to the server using a socket.
  • Send and receive data through the socket asynchronously using BeginSend and BeginReceive.

Data Flow

• Data primarily flows from the server to the clients, with occasional commands from the clients.
• The server sends status data periodically to the clients.
• Received data from clients can be buffered and processed asynchronously, creating jobs on the thread pool to prevent delays in further data reception.

Example Code

using System;
using System.Net;
using System.Net.Sockets;

namespace TcpServer
{
    class xConnection
    {
        public byte[] buffer;
        public System.Net.Sockets.Socket socket;
    }

    class Server
    {
        private List<xConnection> _sockets;
        private System.Net.Sockets.Socket _serverSocket;
        private int _port;
        private int _backlog;

        public bool Start()
        {
            IPHostEntry localhost = Dns.GetHostEntry(Dns.GetHostName());
            IPEndPoint serverEndPoint = new IPEndPoint(localhost.AddressList[0], _port);

            try
            {
                _serverSocket = new Socket(serverEndPoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                _serverSocket.Bind(serverEndPoint);
                _serverSocket.Listen(_backlog);
                _serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
                return true;
            }
            catch (Exception e)
            {
                // Handle exceptions appropriately
                return false;
            }
        }

        private void AcceptCallback(IAsyncResult result)
        {
            try
            {
                Socket serverSocket = (Socket)result.AsyncState;
                xConnection conn = new xConnection();
                conn.socket = serverSocket.EndAccept(result);
                conn.buffer = new byte[_bufferSize];

                lock (_sockets)
                {
                    _sockets.Add(conn);
                }
                conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), conn);
                _serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
            }
            catch (Exception e)
            {
                // Handle exceptions appropriately
            }
        }

        private void Send(byte[] message, xConnection conn)
        {
            if (conn != null &amp;&amp; conn.socket.Connected)
            {
                lock (conn.socket)
                {
                    conn.socket.Send(message, message.Length, SocketFlags.None);
                }
            }
        }
    }
}

Additional Considerations

• Consider using a reassembly protocol for handling incoming data fragments.
• Use a single BeginAccept at any one time to avoid potential bugs.
• Synchronize access to shared resources, such as the client list, to ensure thread safety.

The above is the detailed content of How to Design a Scalable TCP/IP Server with Long-Running Connections?. For more information, please follow other related articles on the PHP Chinese website!