为每个客户端打开不同的tcp端口是否有优势/劣势？

Question

我建立了一个中间件服务器。 我有5个（或6个）客户端（不同的计算机/ IP地址），每个客户端最多可以有6个连接->与服务器的最大36个连接。

最好仅对所有端口使用一个端口（例如9000），或者对每个客户端使用一个不同的端口（例如9000-9005）？

我给我写了一个简单的测试服务器（请参阅代码）。 它的工作与预期的一样，但是可能还有一些优化的空间。

谢谢

我的TCP服务器

public class TCPServerMulti : IDisposable
    { 
    private static TcpListener _tcpListener;
    private string _ipAdress = "";
    private int _port = 9050;
    private readonly Thread _listener;
    private readonly bool _running;

    private int cc = 0; //Test Counter

    public string IPAdress
    {
        get { return _ipAdress; }
        set { _ipAdress = value; }
    }

    public TCPServerMulti(int port)
    {
        if(port>0)
            _port = port;

        _running = true;
        string sHostName = Dns.GetHostName();
        IPAdress = "";
        //Only use the first address -> need to change
        IPAddress[] localAddress = Dns.GetHostAddresses(sHostName);
        foreach (IPAddress ipAddress in localAddress)
        {
            if (ipAddress.AddressFamily == AddressFamily.InterNetwork)
            {
                _tcpListener = new TcpListener(ipAddress, _port);
                IPAdress = ipAddress.ToString();
                break;
            }
        }
        if (IPAdress == "")
        {
            Console.Writeline("TCP Error");
            return;
        }
        _tcpListener.Start();
        _listener = new Thread(Listen) { IsBackground = true };
        _listener.Start();
    }
    public TCPServerMulti():this(-1)
    {}
    //listening for clients
    public void Listen()
    {
        try
        {
            while(_running)
            {
                cc++;
                //create a own client object for every connection
                TCPClientData cd = new TCPClientData(this, ""+cc, _tcpListener.AcceptTcpClient());
                cd.StartClient();
                if (ClientConnected != null) ClientConnected("Connected: " + cc);
            }
            _tcpListener.Stop();
        }
        catch (Exception)
        {
        }
    }

    public void Dispose()
    {
        _listener.Abort();
        _tcpListener.Stop();
    }
    //Handle for Mainthread
    internal void ReceiveClient(TCPClientData sender, string msg)
    {
        if (ReceiveMsg != null)
            ReceiveMsg(sender, msg);
    }

    public delegate void ReceiveEventHandler(TCPClientData sender, string msg);
    public event ReceiveEventHandler ReceiveMsg;

    public delegate void ConnectedEventHandler(string msg);
    public event ConnectedEventHandler ClientConnected;
}

Clientdata对象

public class TCPClientData : IDisposable
{
    private TCPServerMulti _master;
    private byte[] _data;
    private NetworkStream _networkStream;
    private int _received;
    private TcpClient _tcpClient;

    private Thread _worker;
    private bool _wrunning;

    private string _id;
    public TCPClientData(TCPServerMulti master,string id,TcpClient client)
    {
        _data = new byte[1024];
        _master = master;
        _id = id;
        _tcpClient = client;
    }

    public string ID
    {
        get { return _id; }
    }

    private string ByteArrayToString(byte[] arr)
    {
        UTF8Encoding enc = new UTF8Encoding();
        return enc.GetString(arr);
    }

    private byte[] StringToByteArray(string data)
    {
        UTF8Encoding enc = new UTF8Encoding();
        return enc.GetBytes(data);
    }
    // Reading Data
    private void Worker()
    {
        try
        {
            while (_wrunning)
            {

                if (_networkStream.DataAvailable)
                {
                    _received = _networkStream.Read(_data, 0, _data.Length);

                    string s = ByteArrayToString(_data);
                    _master.ReceiveClient(this, s.Substring(0, _received));
                }
                else
                {
                    Thread.Sleep(20);
                }
            }
            _networkStream.Close();
            _tcpClient.Close();
        }
        catch (Exception)
        { }
    }

    public void Dispose()
    {
        _worker.Abort();
        _networkStream.Close();
        _tcpClient.Close();
    }

    public void StartClient()
    {
        _networkStream = _tcpClient.GetStream();
        _networkStream.ReadTimeout = 200;
        _wrunning = true;
        _worker = new Thread(Worker) { IsBackground = true };
        _worker.Start();
    }
    public void StopClient()
    {
        _wrunning = false;
        Thread.Sleep(700);
    }
    //Sending Data
    public void WriteData(string msg)
    {
        byte[] b = StringToByteArray(msg);
        _networkStream.Write(b,0,b.Length);
        _networkStream.Flush();
    }
}

主线程

static void Main(string[] args)
    {
        //Create Server
        TCPServerPlugin.TCPServerMulti server=new TCPServerMulti(12345);
        server.ClientConnected += Server_ClientConnected;
        server.ReceiveMsg += Server_ReceiveMsg;
        while (true)
        {

        }
    }
    //Callbacks
    private static void Server_ClientConnected(string msg)
    {
        Console.WriteLine(msg);
    }

    private static void Server_ReceiveMsg(TCPClientData sender, string msg)
    {
        Console.WriteLine(string.Format("Sender: {0} -> MSG:{1}",sender.ID,msg));
        if (msg == "!!X")
        {
            sender.Dispose();
            sender = null;
        }
        else if(msg=="DATE")
            sender.WriteData(DateTime.Now.ToLongDateString());
        else if(msg=="TIME")
            sender.WriteData(DateTime.Now.ToShortTimeString());
    }