绑定时 C# async SocketException

Question

我正在使用异步套接字在 C# 上开发客户端-服务器应用程序。当我监听连接时，我不断收到此错误

An unhandled exception of type 'System.Net.Sockets.SocketException' occurred in System.dll

Additional information: Only one usage of each socket address (protocol/network address/port) is normally permitted

这是发生此异常的行：

 _listener.Bind(new IPEndPoint(0, port));

代码在Listener.Start(int port)下。在主程序中，我是这样调用方法的：

void btnListen_Click(object sender, EventArgs e)
        {
            _listener = new Listener();
            _listener.Accepted += new Listener.SocketAcceptedHandler(listener_Accepted);
            _listener.Start(8192);
        }

我正在我的 PC 上测试客户端和服务器应用程序。

这是 Listener class.

namespace serverPC
{
    class Listener
    {
        public delegate void SocketAcceptedHandler(Socket e);
        public event SocketAcceptedHandler Accepted;

        Socket _listener;
        public int Port;

        public bool Running
        {
            get;
            private set;
        }

        public Listener() {Port = 0;}

        public void Start(int port)
        {
            if (Running)
                return;

            _listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            _listener.Bind(new IPEndPoint(0, port)); // This is where the SocketException error occurs
            _listener.Listen(0);

            _listener.BeginAccept(acceptedCallback, null);
            Running = true;
        }

        public void Stop()
        {
            if (!Running)
                return;

            _listener.Close();
            Running = false;
        }

        void acceptedCallback(IAsyncResult ar)
        {
            try
            {
                Socket s = _listener.EndAccept(ar);

                if (Accepted != null)
                {
                    Accepted(s);
                }
            }
            catch
            {

            }

            if (Running)
            {
                try
                {
                    _listener.BeginAccept(acceptedCallback, null);
                }
                catch
                {

                }
            }
        }
    }
    
}

这是 Client class.

namespace serverPC
{
    struct ReceiveBuffer
    {
        public const int BUFFER_SIZE = 1024;
        public byte[] Buffer;
        public int ToReceive;
        public MemoryStream BufStream;
  
        public ReceiveBuffer(int toRec)
        {
            Buffer = new byte[BUFFER_SIZE];
            ToReceive = toRec;
            BufStream = new MemoryStream(toRec);
        }

        public void Dispose()
        {
            Buffer = null;
            ToReceive = 0;
            Close();
            if (BufStream != null)
                BufStream.Dispose();
        }

        public void Close()
        {
            if (BufStream != null && BufStream.CanWrite)
            {
                BufStream.Close();
            }
        }
    }

    class Client
    {
        byte[] lenBuffer;
        ReceiveBuffer buffer;
        Socket _socket;

        public IPEndPoint EndPoint
        {
            get
            {
                if (_socket != null && _socket.Connected)
                {
                    return (IPEndPoint)_socket.RemoteEndPoint;
                }

                return new IPEndPoint(IPAddress.None, 0);
            }
        }

        public delegate void DisconnectedEventHandler(Client sender);
        public event DisconnectedEventHandler Disconnected;
        public delegate void DataReceivedEventHandler(Client sender, ReceiveBuffer e);
        public event DataReceivedEventHandler DataReceived;

        public Client(Socket s)
        {
            _socket = s;
            lenBuffer = new byte[4];
        }

        public void Close()
        {
            if (_socket != null)
            {
                _socket.Disconnect(false);
                _socket.Close();
            }

            buffer.Dispose();
            _socket = null;
            lenBuffer = null;
            Disconnected = null;
            DataReceived = null;
        }

        public void ReceiveAsync()
        {
            _socket.BeginReceive(lenBuffer, 0, lenBuffer.Length, SocketFlags.None, receiveCallback, null);
        }

        void receiveCallback(IAsyncResult ar)
        { 
            try
            {
                int rec = _socket.EndReceive(ar);

                if (rec == 0)
                {
                    if (Disconnected != null)
                    {
                        Disconnected(this);
                        return;
                    }

                    if (rec != 4)
                    {
                        throw new Exception();
                    }
                }
            }

            catch (SocketException se)
            {
                switch (se.SocketErrorCode)
                {
                    case SocketError.ConnectionAborted:
                    case SocketError.ConnectionReset:
                        if (Disconnected != null)
                        {
                            Disconnected(this);
                            return;
                        }
                        break;
                }
            }
            catch (ObjectDisposedException)
            {
                return;
            }
            catch (NullReferenceException)
            {
                return;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return;
            }

            buffer = new ReceiveBuffer(BitConverter.ToInt32(lenBuffer, 0));

            _socket.BeginReceive(buffer.Buffer, 0, buffer.Buffer.Length, SocketFlags.None, receivePacketCallback, null);

        }

        void receivePacketCallback(IAsyncResult ar)
        {
            int rec = _socket.EndReceive(ar);

            if (rec <= 0)
            {
                return;
            }

            buffer.BufStream.Write(buffer.Buffer, 0, rec);

            buffer.ToReceive -= rec;

            if(buffer.ToReceive > 0)
            {
                Array.Clear(buffer.Buffer, 0, buffer.Buffer.Length);

                _socket.BeginReceive(buffer.Buffer, 0, buffer.Buffer.Length, SocketFlags.None, receivePacketCallback, null);
                return;
            }

            if (DataReceived != null)
            {
                buffer.BufStream.Position = 0;
                DataReceived(this, buffer);
            }

            buffer.Dispose();

            ReceiveAsync();
        }
    }
}

为什么会出现 SocketException 错误？任何帮助表示赞赏。谢谢！

Answer 1

所以很明显需要检查的事情 - 有些东西已经在侦听端口 8192，或者有其他原因导致您的机器拒绝打开该端口的程序（防火墙等）。

另一个问题是，当您使用 "Running" 检查阻止绑定两次时，您只是为侦听器实例这样做 - 点击按钮将创建一个全新的侦听器并尝试拥有它在端口 8192 上侦听 - 因为您已经在那里绑定了一个侦听器，所以会因该异常而失败。

绑定时 C# async SocketException

C# async SocketException while binding

c#

sockets

asynchronous

runtime-error

asyncsocket