C# C中TCP通信的服务器端口忙问题#

我在C#中使用TCP通信进行客户机-服务器通信

许多客户端都试图一次连接到TCP服务器

我面临服务器端口忙的问题。下面是我的服务器和客户端代码

有没有办法，我可以解决服务器端口忙的问题

Server Code
     /// <summary>
        /// 
        /// </summary>
        public void initializeListener(int iPortNumber,int iActivationPortNumber)
        {
            try
            {
                // BLTablePrototype.TablePrototypeDetails();
                System.Net.IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
                System.Net.IPAddress ipaddress = ipHostInfo.AddressList[0];

                serverSocket = new TcpListener(ipaddress, iPortNumber);

                try
                {
                    serverSocket.Stop();

                }
                catch { }

                serverSocket.Start();

                Common.BLConstants.isListnerStarted = true;



                //StartAccept();
                //WaitForClients();
            }
            catch (Exception ex)
            {

            }
        }


        public void ReceiveTCP()
        {  
            try
            {
                while (true)
                {
                    if (serverSocket.Pending())
                    {
                        TcpClient client = client = serverSocket.AcceptTcpClient();                        
                        if (client.Connected)
                        {
                            Thread thread = new Thread(WorkThread);
                            thread.Start(client);
                        }                      
                    }
                    else
                    {
                        Thread.Sleep(30000);
                    }
                }

            }
            catch (Exception ex)
            {

            }

        }


client Code

  client = new TcpClient();
                var result = client.BeginConnect(Wipro.EUA.Library.Cryptography.Decrypt(Common.BLConstants.strServerIPAddress), iPortnumber, null, null);
                result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(2));

                if (client.Connected)
                {

                    byte[] SendingBuffer = Encoding.UTF8.GetBytes(XElement.ToString());
                    netstream = client.GetStream();

                    int NoOfPackets = Convert.ToInt32(Math.Ceiling(Convert.ToDouble(SendingBuffer.Length) / Convert.ToDouble(BLConstants.iBufferSize)));
                    int TotalLength = (int)SendingBuffer.Length, CurrentPacketLength, FinalLength = 0, RemainingLength = TotalLength;
                    for (int k = 0; k < NoOfPackets; k++)
                    {
                        if (RemainingLength > BLConstants.iBufferSize)
                        {
                            if (k == 0)
                                CurrentPacketLength = k * BLConstants.iBufferSize;
                            else
                                CurrentPacketLength = k * BLConstants.iBufferSize;

                            FinalLength = CurrentPacketLength + BLConstants.iBufferSize;
                            RemainingLength = TotalLength - FinalLength;
                            netstream.Write(SendingBuffer, CurrentPacketLength, BLConstants.iBufferSize);
                        }
                        else
                        {
                            CurrentPacketLength = FinalLength;
                            netstream.Write(SendingBuffer, CurrentPacketLength, TotalLength - CurrentPacketLength);
                        }
                    }
                }

                client.EndConnect(result);
                isSuccess = true;

服务器代码
/// 
/// 
/// 
公共无效初始化侦听器（int iPortNumber、int iActivationPortNumber）
{
尝试
{
//BLTablePrototype.TablePrototypeDetails（）；
System.Net.IPHostEntry ipHostInfo=Dns.Resolve（Dns.GetHostName（））；
System.Net.IPAddress IPAddress=ipHostInfo.AddressList[0]；
serverSocket=新的TcpListener（ipaddress，iPortNumber）；
尝试
{
serverSocket.Stop（）；
}
捕获{}
serverSocket.Start（）；
Common.BLConstants.isListnerStarted=true；
//startacept（）；
//WaitForClients（）；
}
捕获（例外情况除外）
{
}
}
公共无效接收TCP（）
{  
尝试
{
while（true）
{
if（serverSocket.Pending（））
{
TcpClient client=client=serverSocket.AcceptTcpClient（）；
如果（客户端已连接）
{
螺纹=新螺纹（工作螺纹）；
线程启动（客户端）；
}                      
}
其他的
{
睡眠（30000）；
}
}
}
捕获（例外情况除外）
{
}
}
客户端代码
client=新的TcpClient（）；
var result=client.BeginConnect（Wipro.EUA.Library.Cryptography.decryption（Common.BLConstants.strServerIPAddress），iPortnumber，null，null）；
result.AsyncWaitHandle.WaitOne（TimeSpan.FromSeconds（2））；
如果（客户端已连接）
{
byte[]SendingBuffer=Encoding.UTF8.GetBytes（XElement.ToString（））；
netstream=client.GetStream（）；
int NoOfPackets=Convert.ToInt32（数学上限（Convert.ToDouble（SendingBuffer.Length）/Convert.ToDouble（BLConstants.iBufferSize））；
int TotalLength=（int）SendingBuffer.Length，CurrentPacketLength，FinalLength=0，RemainingLength=TotalLength；
对于（int k=0；kBLConstants.iBufferSize）
{
如果（k==0）
CurrentPacketLength=k*BLConstants.iBufferSize；
其他的
CurrentPacketLength=k*BLConstants.iBufferSize；
FinalLength=CurrentPacketLength+BLConstants.iBufferSize；
剩余长度=总长度-最终长度；
Write（SendingBuffer、CurrentPacketLength、BLConstants.iBufferSize）；
}
其他的
{
CurrentPacketLength=最终长度；
Write（SendingBuffer，CurrentPacketLength，TotalLength-CurrentPacketLength）；
}
}
}
客户端.EndConnect（结果）；
isSuccess=true；

我在C#中使用TCP通信进行客户机-服务器通信

许多客户端都试图一次连接到TCP服务器

我面临服务器端口忙的问题。下面是我的服务器和客户端代码

---

有没有办法，我可以解决服务器端口忙的问题。

正如@MickyD所评论的，问题是：

Server Code
     /// <summary>
        /// 
        /// </summary>
        public void initializeListener(int iPortNumber,int iActivationPortNumber)
        {
            try
            {
                // BLTablePrototype.TablePrototypeDetails();
                System.Net.IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
                System.Net.IPAddress ipaddress = ipHostInfo.AddressList[0];

                serverSocket = new TcpListener(ipaddress, iPortNumber);

                try
                {
                    serverSocket.Stop();

                }
                catch { }

                serverSocket.Start();

                Common.BLConstants.isListnerStarted = true;



                //StartAccept();
                //WaitForClients();
            }
            catch (Exception ex)
            {

            }
        }


        public void ReceiveTCP()
        {  
            try
            {
                while (true)
                {
                    if (serverSocket.Pending())
                    {
                        TcpClient client = client = serverSocket.AcceptTcpClient();                        
                        if (client.Connected)
                        {
                            Thread thread = new Thread(WorkThread);
                            thread.Start(client);
                        }                      
                    }
                    else
                    {
                        Thread.Sleep(30000);
                    }
                }

            }
            catch (Exception ex)
            {

            }

        }


client Code

  client = new TcpClient();
                var result = client.BeginConnect(Wipro.EUA.Library.Cryptography.Decrypt(Common.BLConstants.strServerIPAddress), iPortnumber, null, null);
                result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(2));

                if (client.Connected)
                {

                    byte[] SendingBuffer = Encoding.UTF8.GetBytes(XElement.ToString());
                    netstream = client.GetStream();

                    int NoOfPackets = Convert.ToInt32(Math.Ceiling(Convert.ToDouble(SendingBuffer.Length) / Convert.ToDouble(BLConstants.iBufferSize)));
                    int TotalLength = (int)SendingBuffer.Length, CurrentPacketLength, FinalLength = 0, RemainingLength = TotalLength;
                    for (int k = 0; k < NoOfPackets; k++)
                    {
                        if (RemainingLength > BLConstants.iBufferSize)
                        {
                            if (k == 0)
                                CurrentPacketLength = k * BLConstants.iBufferSize;
                            else
                                CurrentPacketLength = k * BLConstants.iBufferSize;

                            FinalLength = CurrentPacketLength + BLConstants.iBufferSize;
                            RemainingLength = TotalLength - FinalLength;
                            netstream.Write(SendingBuffer, CurrentPacketLength, BLConstants.iBufferSize);
                        }
                        else
                        {
                            CurrentPacketLength = FinalLength;
                            netstream.Write(SendingBuffer, CurrentPacketLength, TotalLength - CurrentPacketLength);
                        }
                    }
                }

                client.EndConnect(result);
                isSuccess = true;

Thread.Sleep(30000);

您只接受一个连接，然后睡眠30秒。显然，在这30秒内尝试连接的客户端将不会得到响应（超时）

实际上，解决方案非常简单。
您不需要使用

挂起

和

睡眠

只使用

acceptcpclient

就足够了

acceptcpclient

是一种阻塞方法。它将阻塞，直到连接到达

使用

Pending

的原因是，如果您不想阻止，但是您正在使用

线程以任何方式阻止。Sleep（30000）

所有这些都包含在以下内容中：

AcceptTcpClient是一种阻塞方法，它返回一个TcpClient，可用于发送和接收数据。如果要避免阻塞，请使用Pending方法确定传入连接队列中是否有可用的连接请求

此外，您不需要检查客户端是否已连接（您正在获得连接…） 因此，您的循环可以变得更简单：

while (true)
{
    TcpClient client = client = serverSocket.AcceptTcpClient();                        
    Thread thread = new Thread(WorkThread);
    thread.Start(client);
}

---

Thread.Sleep（30000）

这是一种帮助客户端超时连接的好方法TcpListener默认为允许100个客户端连接。您不需要为每个客户机执行“新建”。出现错误，因为侦听器正在使用IPortNumber连接到计算机中的虚拟侦听地址，并且只能使用该端口号进行一次连接。要处理多个客户端，请使用Asyn方法。每次新客户端连接时，Accept方法都会给出一个新的客户端套接字对象。