如何在 C# 中检查套接字是否已连接/断开？

Question

如果其他主机在断开连接时没有向您发送数据包（例如，因为它不正常地断开连接），如何检查网络套接字（System.Net.Sockets.Socket）是否仍然连接？

Answer 1

正如 Paul Turner 回答的那样，Socket.Connected 在这种情况下不能使用。您需要每次轮询连接以查看连接是否仍然活动。这是我使用的代码：

bool SocketConnected(Socket s)
{
    bool part1 = s.Poll(1000, SelectMode.SelectRead);
    bool part2 = (s.Available == 0);
    if (part1 && part2)
        return false;
    else
        return true;
}

它的工作原理如下：

• s.Poll 返回 true 如果
  • 连接已关闭、重置、终止或待处理（表示没有活动连接）
  • 连接处于活动状态并且有数据可供读取
• /library/system.net.sockets.socket.available.aspx" rel="noreferrer">s.Available如果两者都为 true， ：
  • 没有可供读取的数据，因此连接未处于活动状态

Answer 2

正如 zendar 所写，使用 Socket.Poll 和 Socket 很好。可用，但您需要考虑到套接字可能尚未初始化。这是最后一条信息（我相信），它由 Socket.Connected 属性提供。该方法的修订版本看起来像这样：

 static bool IsSocketConnected(Socket s)
    {
        return !((s.Poll(1000, SelectMode.SelectRead) && (s.Available == 0)) || !s.Connected);

/* The long, but simpler-to-understand version:

        bool part1 = s.Poll(1000, SelectMode.SelectRead);
        bool part2 = (s.Available == 0);
        if ((part1 && part2 ) || !s.Connected)
            return false;
        else
            return true;

*/
    }

Answer 3

Socket.Connected 属性将告诉您套接字是否认为已连接。它实际上反映了在套接字上执行的最后一次发送/接收操作的状态。

如果套接字已被您自己的操作关闭（处置套接字、调用方法来断开连接），Socket.Connected 将返回 false。如果套接字已通过其他方式断开连接，则该属性将返回 true 直到您下一次尝试发送或接收信息，此时将出现 SocketException 或 ObjectDispositedException 将被抛出。

您可以在异常发生后检查该属性，但在发生异常之前它并不可靠。

Answer 4

如果拔掉网线，接受的答案似乎不起作用。或者服务器崩溃。或者你的路由器崩溃了。或者如果您忘记支付互联网账单。设置 TCP 保持活动选项以获得更好的可靠性。

public static class SocketExtensions
{
    public static void SetSocketKeepAliveValues(this Socket instance, int KeepAliveTime, int KeepAliveInterval)
    {
        //KeepAliveTime: default value is 2hr
        //KeepAliveInterval: default value is 1s and Detect 5 times

        //the native structure
        //struct tcp_keepalive {
        //ULONG onoff;
        //ULONG keepalivetime;
        //ULONG keepaliveinterval;
        //};

        int size = Marshal.SizeOf(new uint());
        byte[] inOptionValues = new byte[size * 3]; // 4 * 3 = 12
        bool OnOff = true;

        BitConverter.GetBytes((uint)(OnOff ? 1 : 0)).CopyTo(inOptionValues, 0);
        BitConverter.GetBytes((uint)KeepAliveTime).CopyTo(inOptionValues, size);
        BitConverter.GetBytes((uint)KeepAliveInterval).CopyTo(inOptionValues, size * 2);

        instance.IOControl(IOControlCode.KeepAliveValues, inOptionValues, null);
    }
}



// ...
Socket sock;
sock.SetSocketKeepAliveValues(2000, 1000);

时间值设置自上次发送数据以来的超时时间。然后它尝试发送和接收保持活动数据包。如果失败，它会在指定的时间间隔内重试 10 次（自 Vista AFAIK 以来硬编码的次数），然后再确定连接已失效。

因此上述值将导致 2+10*1 = 12 秒检测。之后，套接字上的任何读取/写入/轮询操作都将失败。

Answer 5

public static class SocketExtensions
{
    private const int BytesPerLong = 4; // 32 / 8
    private const int BitsPerByte = 8;

    public static bool IsConnected(this Socket socket)
    {
        try
        {
            return !(socket.Poll(1000, SelectMode.SelectRead) && socket.Available == 0);
        }
        catch (SocketException)
        {
            return false;
        }
    }


    /// <summary>
    /// Sets the keep-alive interval for the socket.
    /// </summary>
    /// <param name="socket">The socket.</param>
    /// <param name="time">Time between two keep alive "pings".</param>
    /// <param name="interval">Time between two keep alive "pings" when first one fails.</param>
    /// <returns>If the keep alive infos were succefully modified.</returns>
    public static bool SetKeepAlive(this Socket socket, ulong time, ulong interval)
    {
        try
        {
            // Array to hold input values.
            var input = new[]
            {
                (time == 0 || interval == 0) ? 0UL : 1UL, // on or off
                time,
                interval
            };

            // Pack input into byte struct.
            byte[] inValue = new byte[3 * BytesPerLong];
            for (int i = 0; i < input.Length; i++)
            {
                inValue[i * BytesPerLong + 3] = (byte)(input[i] >> ((BytesPerLong - 1) * BitsPerByte) & 0xff);
                inValue[i * BytesPerLong + 2] = (byte)(input[i] >> ((BytesPerLong - 2) * BitsPerByte) & 0xff);
                inValue[i * BytesPerLong + 1] = (byte)(input[i] >> ((BytesPerLong - 3) * BitsPerByte) & 0xff);
                inValue[i * BytesPerLong + 0] = (byte)(input[i] >> ((BytesPerLong - 4) * BitsPerByte) & 0xff);
            }

            // Create bytestruct for result (bytes pending on server socket).
            byte[] outValue = BitConverter.GetBytes(0);

            // Write SIO_VALS to Socket IOControl.
            socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
            socket.IOControl(IOControlCode.KeepAliveValues, inValue, outValue);
        }
        catch (SocketException)
        {
            return false;
        }

        return true;
    }
}

1. 将 SocketExtensions 类复制到您的项目
2. 在套接字上调用 SetKeepAlive - socket.SetKeepAlive(1000, 2);
3. 添加一个定时器来检查 IsConnected 函数

Answer 6

我基于 this 制作了一个扩展方法 MSDN 文章。
这是如何确定套接字是否仍处于连接状态的方法。

public static bool IsConnected(this Socket client)
{
    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 7

正如 Alexander Logger 在 zendar的回答，你必须发送一些东西才能完全确定。
如果您的关联伙伴
不在此套接字上读取
所有，您可以使用以下
代码。

bool SocketConnected(Socket s)
{
  // Exit if socket is null
  if (s == null)
    return false;
  bool part1 = s.Poll(1000, SelectMode.SelectRead);
  bool part2 = (s.Available == 0);
  if (part1 && part2)
    return false;
  else
  {
    try
    {
      int sentBytesCount = s.Send(new byte[1], 1, 0);
      return sentBytesCount == 1;
    }
    catch
    {
      return false;
    }
  }
}

但即便如此，也可能需要几秒钟的时间才能检测到网络电缆损坏或类似情况。

Answer 8

遵循 NibblyPig 和 的建议zendar，我想出了下面的代码，它适用于我所做的每个测试。我最终需要 ping 和 poll。 ping 将让我知道电缆是否已断开，或者物理层是否已中断（路由器断电等）。但有时重新连接后我会收到 RST，ping 正常，但 tcp 状态却不行。

#region CHECKS THE SOCKET'S HEALTH
    if (_tcpClient.Client.Connected)
    {
            //Do a ping test to see if the server is reachable
            try
            {
                Ping pingTest = new Ping()
                PingReply reply = pingTest.Send(ServeripAddress);
                if (reply.Status != IPStatus.Success) ConnectionState = false;
            } catch (PingException) { ConnectionState = false; }

            //See if the tcp state is ok
            if (_tcpClient.Client.Poll(5000, SelectMode.SelectRead) && (_tcpClient.Client.Available == 0))
            {
                ConnectionState = false;
            }
        }
    }
    else { ConnectionState = false; }
#endregion

Answer 9

最好的方法就是让您的客户端每 X 秒发送一次 PING，并且服务器在一段时间内没有收到 PING 消息后假设它已断开连接。

我在使用套接字时遇到了与您相同的问题，这是我能做到的唯一方法。 socket.connected 属性从来都不正确。

但最终，我转而使用 WCF，因为它比套接字可靠得多。

Answer 10

只需像 @toster-cx 所说的那样使用 KeepAlive，然后使用 Socket Connected 状态来检查 Socket 是否仍处于连接状态。将接收超时设置为与保持连接超时相同。如果您有更多问题，我很乐意为您提供帮助！

Answer 11

使用 Socket.Connected 属性。

--更新--

正如 Paul Turner 所回答的那样，在这种情况下不能使用 Socket.Connected 。您需要每次轮询连接以查看连接是否仍然活动。请参阅2