Question

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

未处理的类型＆＃39; System.Net.Sockets.SocketException＆＃39;   发生在System.dll
中
附加信息：通常只允许使用每个套接字地址（协议/网络地址/端口）

这是发生此异常的行：

 _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班。

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班。

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上侦听，或者还有其他原因导致你的机器拒绝打开该端口的程序（防火墙等）。

另一个问题是当您使用＆＃34; Running＆＃34;阻止绑定两次时检查，你只是为侦听器的实例做这个 - 按下按钮将创建一个全新的侦听器并尝试让它侦听端口8192 - 因为你已经有一个绑定在那里的侦听器，将失败该异常

绑定时出现C＃异步SocketException

1 个答案: