TCPClient连接后如何测试是否断线？

Question

我已经与一个问题斗争了整整三天，我找不到任何解决方案，请帮助:)
我使用 Visual Studio 2010 和 C# 语言。

我有一个像服务器一样工作的设备，它在非常不规则的时间段内发送一些数据（无法定义任何读取超时）。
我编写了一个 TCP 客户端来连接到该服务器并读取数据。它工作正常，但是当网络出现问题并且服务器变得不可用时（例如，当我从计算机上拔掉网络电缆时），应用程序需要大约 10 秒的时间“注意到”没有与服务器的连接并抛出异常一个例外。 （我不知道为什么正好是10秒？它在哪里定义的？我可以更改它吗？）
我想反应更快 - 比如说连接断开后一秒钟。
然而，谷歌搜索答案并没有为我提供任何可行的解决方案。

测试代码如下，我尝试在 2 个线程上进行：一个正在读取数据，第二个正在查找连接状态，并且应该在连接断开时向我发出警报。它不适用于 TCPClient 和 Socket 类。我尝试使用 tcpClient.SendTimeout = 100; 和 stream.WriteTimeout = 100; 读取/写入一些数据，但它似乎不起作用。

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Threading;

namespace TCPClient
{
    class Program
    {
        static volatile bool _continue = true;
        static TcpClient tcpClient;
        static NetworkStream stream;

        static void Main(string[] args)
        {
            try
            {
                //client thread - listen from server
                Thread tcpListenThread = new Thread(TcpListenThread);
                tcpListenThread.Start();

                //connection checking thread
                Thread keepAliveThread = new Thread(KeepAliveThread);
                keepAliveThread.Start();

                while (_continue)
                {
                    if (Console.ReadLine() == "q")
                    {
                        _continue = false;
                    }
                }

                keepAliveThread.Join(2000);
                if (keepAliveThread.IsAlive)
                {
                    Console.WriteLine("Thread keepAlive has been aborted...");
                    keepAliveThread.Abort();
                }

                tcpListenThread.Join(2000);
                if (tcpListenThread.IsAlive)
                {
                    Console.WriteLine("Listen thread has been aborted...");
                    tcpListenThread.Abort();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("\n" + ex.Message);
            }

            Console.WriteLine("\nHit any key to quit...");
            Console.Read();
        }

        private static void TcpListenThread()
        {
            string server = "172.20.30.40";
            int port = 3000;

            try
            {
                using (tcpClient = new TcpClient())
                {
                    tcpClient.Connect(server, port);

                    if (tcpClient.Connected)
                        Console.WriteLine("Successfully connected to server");

                    using (stream = tcpClient.GetStream())
                    {

                        while (_continue)
                        {
                            Byte[] data = new Byte[1024];
                            Int32 bytes = stream.Read(data, 0, data.Length);
                            string responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);

                            Console.WriteLine("Received: {0}, responseData);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Listen thread exception! " + ex.Message);
            }
        }


        private static void KeepAliveThread()
        {
            while (_continue)
            {
                if (tcpClient != null)
                {
                    try
                    {
                        //...what to put here to check or throw exception when server is not available??...
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Disconnected...");
                    }
                }

                Thread.Sleep(1000);  //test for connection every 1000ms
            }
        }
    }
}

编辑：
@carsten 的回答：虽然看起来很有希望，但这个解决方案不起作用......
我为此制作了最简单的测试应用程序：

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Threading;

namespace TCPClientTest
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                string server = "172.20.30.40";
                int port = 3000;

                using (TcpClient tcpClient = new TcpClient())
                {
                    tcpClient.Connect(server, port);

                    int i = 0;
                    while (true)
                    {
                        // This is how you can determine whether a socket is still connected.
                        bool blockingState = tcpClient.Client.Blocking;
                        try
                        {
                            byte[] tmp = new byte[1];

                            tcpClient.Client.Blocking = false;
                            tcpClient.Client.Send(tmp, 0, 0);
                            Console.WriteLine("Connected!");
                        }
                        catch (SocketException e)
                        {
                            // 10035 == WSAEWOULDBLOCK
                            if (e.NativeErrorCode.Equals(10035))
                                Console.WriteLine("Still Connected, but the Send would block");
                            else
                            {
                                Console.WriteLine("Disconnected: error code {0}!", e.NativeErrorCode);
                            }
                        }
                        finally
                        {
                            tcpClient.Client.Blocking = blockingState;
                        }

                        Console.WriteLine("Connected: {0} ({1})", tcpClient.Client.Connected, i++);

                        Thread.Sleep(1000);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Global exception: {0}", ex.Message);
            }
        }
    }
}

结果如下，它显示：

已连接！
已连接：True

每秒加上我的订单号。当我断开网络电缆时，需要 8 秒才能开始打印：

断开连接：错误代码 10054！
Connected: False

所以到 8 秒时我不知道连接丢失了。看起来 ping 是最好的选择，但我将测试其他解决方案。

Answer 1

我想这是一个经常出现的问题。这可能就是为什么 MSDN 文档确实对此给出了很好的答案 - 请参阅 Socket.Connected

引用自那里：

Connected 属性获取 Socket 的连接状态
最后一次 I/O 操作。当它返回 false 时，Socket 是
从未连接过，或不再连接过。

Connected 属性的值反映了连接的状态
截至最近一次操作的连接。如果您需要确定
连接的当前状态，创建一个非阻塞、零字节
发送电话。如果调用成功返回或抛出 WAEWOULDBLOCK
错误代码（10035），则套接字仍然处于连接状态；否则，
套接字不再连接。

使用此示例代码：

// .Connect throws an exception if unsuccessful
client.Connect(anEndPoint);

// This is how you can determine whether a socket is still connected.
bool blockingState = client.Blocking;
try
{
    byte [] tmp = new byte[1];

    client.Blocking = false;
    client.Send(tmp, 0, 0);
    Console.WriteLine("Connected!");
}
catch (SocketException e) 
{
    // 10035 == WSAEWOULDBLOCK
    if (e.NativeErrorCode.Equals(10035))
        Console.WriteLine("Still Connected, but the Send would block");
    else
    {
        Console.WriteLine("Disconnected: error code {0}!", e.NativeErrorCode);
    }
}
finally
{
    client.Blocking = blockingState;
}

 Console.WriteLine("Connected: {0}", client.Connected);

以及扩展方法的直接动机：

public static bool IsConnected(this Socket client)
{
   // This is how you can determine whether a socket is still connected.
   bool blockingState = client.Blocking;
   try
   {
       byte [] tmp = new byte[1];

       client.Blocking = false;
       client.Send(tmp, 0, 0);
       return true;
   }
   catch (SocketException e) 
   {
       // 10035 == WSAEWOULDBLOCK
       if (e.NativeErrorCode.Equals(10035))
           return true;
       else
       {
           return false;
       }
   }
   finally
   {
       client.Blocking = blockingState;
   }
}

Answer 2

这是一个非常古老的线程，但这是我搜索这个问题时出现的第一篇 SO 帖子，并且我在其他地方找到了更有用的解决方案，所以我想我应该发布一个链接来帮助其他人将来：

<一href="https://social.msdn.microsoft.com/Forums/en-US/c857cad5-2eb6-4b6c-b0b5-7f4ce320c5cd/c-how-to-确定-if-a-tcpclient-has-been-disconnected ?forum=netfxnetcom&prof=必填" rel="noreferrer">https://social.msdn.microsoft.com/Forums/en-US/c857cad5-2eb6-4b6c-b0b5-7f4ce320c5cd/c-how-to-确定-if-a-tcpclient-has- was-disconnected?forum=netfxnetcom&prof=required

ElFenix 发布了这个对我有用的答案：

// Detect if client disconnected
if (tcp.Client.Poll(0, SelectMode.SelectRead))
{
  byte[] buff = new byte[1];
  if (tcp.Client.Receive(buff, SocketFlags.Peek) == 0)
  {
    // Client disconnected
    bClosed = true;
  }
}

Answer 3

简单的回答。你不能。 Tcp 的制作方式不允许这样做。然而，实现此目的的正常方法是以比消息更短的间隔发送 ping。因此，假设每当您从服务器收到消息时，您都会启动一个倒计时 1 分钟的时钟，然后发送一个“ping”命令（如果您在这期间没有收到新消息）。如果您在 30 秒内没有收到对“ping”的响应，则可以断定连接已断开。

理论上，您应该能够在包级别执行此操作（tcp 发送您应该能够检查的 ACK），但我不知道这在 C# 或任何与此相关的编程语言中是否可行，或者是否可以你需要在固件/硬件中做到这一点。

Answer 4

如果您输入以下内容，它将是正确的并且可以工作：

byte[] tmp = new byte[] {0};
...             
client.Send(tmp, 1, 0);
...

Answer 5

以防万一其他人需要简单而有效的东西。

这是我想出的代码

            while (true)
            {

                string s = null;
                DateTime readLag = DateTime.Now;
                try
                {
                    s = streamIn.ReadLine();
                }
                catch (Exception ex)
                {
                    SocketException sockEx = ex.InnerException as SocketException;
                    if (sockEx != null)
                    {
                        OnDebug("(" + sockEx.NativeErrorCode + ") Exception = " + ex);
                    }
                    else
                    {
                        OnDebug("Not SockEx :" + ex);
                    }
                }



                if (enableLog) OnDebug(s);
                if (s == null || s == "")
                {
                    if (readLag.AddSeconds(.9) > DateTime.Now)
                    {
                        break;
                    }
                }
                else
                {
                    CommandParser(s);
                }
            }

每次读取失败但会阻塞时，我得到的是本机错误 10035。

当连接被破坏时，我立即得到了没有数据的返回。

将 readLag.AddSeconds() 设置为略低于我的读取超时将使我知道时间从未流逝，并且我没有得到任何数据。这不应该发生。

一旦这个标准出现，我就跳出循环，线程结束。

希望这对其他人有帮助。

Answer 6

最初的 unix 实现中有一个名为 SO_KEEPALIVE 的套接字选项，它使 TCP 协议偶尔发送探测以确保管道的另一端仍在侦听。它可以与通过 Socket.IOControl 设置探针的频率一起设置