C# .NET套接字突然停止工作

几个月前，我在当前的项目中编写了一个TCP套接字服务器和客户端，从那时起，它们一直工作得很好。但到今天为止，我根本无法在两台机器之间建立连接，而这两台机器已经在长时间的无故障通信中

设置非常简单：两台机器“A”和“B”通过以太网电缆直接连接，中间没有交换机。机器“A”也连接到我的家庭网络，允许访问互联网。机器“B”仅连接到“A”。我正在“B”上运行TCP服务器，在“A”上运行客户端

我在服务器端使用异步.NET套接字功能BeginAccept etc，在客户端使用BeginConnect etc。调试完两端后，我只能确认服务器端似乎从未收到来自客户端的调用。我还没有接触到代码，它仍然可以在其他机器之间工作

另外，这两台机器之间没有其他通信问题。我使用共享一组键盘/鼠标，正常的UNC路径可以很好地从一台机器浏览另一台机器

我已经测试了不同的端口，我已经关闭了两侧的防火墙。我已经释放/更新了两侧的连接，重新启动了两台机器以及我能想到的所有其他虚拟选项

我承认我对网络不太了解，所以我非常感谢你给我一些提示，告诉我下一步该看什么，因为我现在不知道下一步该看什么。我敢肯定，这一定是我刚刚忽略的一件非常愚蠢的事情；O

编辑样本“spike”代码

应要求，我修改了微软的示例套接字代码，并将其压缩到下面一点。然后，我测试了在机器“B”上同时运行服务器端和客户端，这很好，但在机器“A”上发生了同样的情况。客户端与服务器端没有联系。代码如下：

 public static class SocketServer
{
    private class StateObject
    {
        public Socket _workSocket;
        public const int BufferSize = 1024;
        public readonly byte[] _buffer = new byte[BufferSize];
        public readonly StringBuilder _sb = new StringBuilder();
    }

    private static readonly ManualResetEvent _s_allDone = new ManualResetEvent(false);

    public static void StartListening()
    {
        var ipHostInfo = Dns.Resolve(Dns.GetHostName());
        var ipAddress = ipHostInfo.AddressList[0];
        var localEndPoint = new IPEndPoint(ipAddress, 11000);
        var listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        try
        {
            listener.Bind(localEndPoint);
            listener.Listen(100);
            while (true)
            {
                _s_allDone.Reset();
                Console.WriteLine("Waiting for a connection...");
                listener.BeginAccept(acceptCallback, listener);
                _s_allDone.WaitOne();
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
        Console.WriteLine("\nPress ENTER to continue...");
        Console.Read();
    }

    private static void acceptCallback(IAsyncResult ar)
    {
        _s_allDone.Set();
        var listener = (Socket)ar.AsyncState;
        var handler = listener.EndAccept(ar);
        var state = new StateObject {_workSocket = handler};
        handler.BeginReceive(state._buffer, 0, StateObject.BufferSize, 0, readCallback, state);
    }

    private static void readCallback(IAsyncResult ar)
    {
        var state = (StateObject)ar.AsyncState;
        var handler = state._workSocket;
        int bytesRead = handler.EndReceive(ar);

        if (bytesRead <= 0) 
            return;

        state._sb.Append(Encoding.ASCII.GetString(state._buffer, 0, bytesRead));

        var content = state._sb.ToString();
        if (content.IndexOf("<EOF>") > -1)
        {
            Console.WriteLine("Read {0} bytes from socket. \n Data : {1}", content.Length, content);
        }
        else
        {
            handler.BeginReceive(state._buffer, 0, StateObject.BufferSize, 0, readCallback, state);
        }
    }

    public static int Main(String[] args)
    {
        StartListening();
        return 0;
    }
}

public static class SocketClient
{
    private class StateObject
    {
        public Socket _workSocket;
        public const int BufferSize = 256;
        public readonly byte[] _receiveBuffer = new byte[BufferSize];
        public readonly StringBuilder _sb = new StringBuilder();
    }

    private const int RemotePort = 11000;
    private static readonly ManualResetEvent _s_connectDone = new ManualResetEvent(false);
    private static readonly ManualResetEvent _s_sendDone = new ManualResetEvent(false);
    private static readonly ManualResetEvent _s_receiveDone = new ManualResetEvent(false);

    // The response from the remote device.
    private static String _s_response = String.Empty;

    private static void startClient()
    {
        try
        {
            _s_connectDone.WaitOne(2000); // <-- gives server time to boot when on same machine
            var ipHostInfo = Dns.Resolve(Dns.GetHostName());
            var ipAddress = ipHostInfo.AddressList[0];
            var remoteEndPoint = new IPEndPoint(ipAddress, RemotePort);
            var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            client.BeginConnect(remoteEndPoint, connectCallback, client);
            _s_connectDone.WaitOne();
            send(client, "This is a test<EOF>");
            _s_sendDone.WaitOne();
            receive(client);
            _s_receiveDone.WaitOne();
            Console.WriteLine("Response received : {0}", _s_response);
            client.Shutdown(SocketShutdown.Both);
            client.Close();

        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }

    private static void connectCallback(IAsyncResult ar)
    {
        try
        {
            var client = (Socket)ar.AsyncState;
            client.EndConnect(ar);
            Console.WriteLine("Socket connected to {0}", client.RemoteEndPoint);
            _s_connectDone.Set();
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }

    private static void receive(Socket client)
    {
        try
        {
            var state = new StateObject {_workSocket = client};
            client.BeginReceive(state._receiveBuffer, 0, StateObject.BufferSize, 0, receiveCallback, state);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }

    private static void receiveCallback(IAsyncResult ar)
    {
        try
        {
            var state = (StateObject)ar.AsyncState;
            var client = state._workSocket;
            var bytesRead = client.EndReceive(ar);

            if (bytesRead > 0)
            {
                state._sb.Append(Encoding.ASCII.GetString(state._receiveBuffer, 0, bytesRead));
                client.BeginReceive(state._receiveBuffer, 0, StateObject.BufferSize, 0, receiveCallback, state);
            }
            else
            {
                if (state._sb.Length > 1)
                {
                    _s_response = state._sb.ToString();
                }
                _s_receiveDone.Set();
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }

    private static void send(Socket client, String data)
    {
        var byteData = Encoding.ASCII.GetBytes(data);
        client.BeginSend(byteData, 0, byteData.Length, 0, sendCallback, client);
    }

    private static void sendCallback(IAsyncResult ar)
    {
        try
        {
            var client = (Socket)ar.AsyncState;
            var bytesSent = client.EndSend(ar);
            Console.WriteLine("Sent {0} bytes to server.", bytesSent);
            _s_sendDone.Set();
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }

    public static int Main()
    {
        startClient();
        return 0;
    }
}

---

你能用小的测试客户机和服务器程序重现这个吗？如果是的话，把它们贴出来！你是否在网络上添加了路由器或任何其他更改？我应该补充的是，我还仔细检查了名称解析，它生成了正确的IP号。你似乎已经拘留了大多数常见的嫌疑人。在第一段之后，我立即想到了“关闭所有路由器”，但你没有。这一定是服务器或客户端的一个无用配置问题，对吗？如果将服务器和telnet运行到服务器盒本身的服务器端口，会发生什么情况？如果有效，请在客户端框中尝试相同的方法。如果是我，我也会认为“愚蠢”：我认为“telnet”可能是个主意，但实际上我以前从未使用过它，所以我不知道如何使用。你能用小型测试客户端和服务器程序重现这个想法吗？如果是的话，把它们贴出来！你是否在网络上添加了路由器或任何其他更改？我应该补充的是，我还仔细检查了名称解析，它生成了正确的IP号。你似乎已经拘留了大多数常见的嫌疑人。在第一段之后，我立即想到了“关闭所有路由器”，但你没有。这一定是服务器或客户端的一个无用配置问题，对吗？如果将服务器和telnet运行到服务器盒本身的服务器端口，会发生什么情况？如果有效，请在客户端框中尝试相同的方法。如果是我，我也会觉得“愚蠢”：我认为“telnet”可能是个主意，但实际上我以前从未使用过，所以我不知道如何使用它。