TCP/IP多线程异步监听多端口

Question

监听多个端口的程序，每个端口会有多个客户端连接发送数据，实现了异步监听，但是停止监听按钮里的代码不知道怎么写了，在线求助。

Answer 1

socket.Close();
tcpListener.Stop();

Answer 2

如果你使用线程了，把线程也给Abort()了吧

Answer 3

我是监听一个端口，开一个线程，然后把线程放到一个集合里
停止监听后，将线程全部Abort()了，

Answer 4

tcpListener.Stop();
我没有该类

Answer 5

你没有建立TcpListener监听吗？

Answer 6

     ipep = new IPEndPoint(HostIP, Convert.ToInt32(item.InetPort));//指定端口
                        Thread thread = new Thread(new ParameterizedThreadStart(StartListening));
                        thread.Start(ipep);//开始线程
                        myDataRS.listthread.Add(thread);//添加到线程集合                IPEndPoint localEndPoint = (IPEndPoint)obj;
                Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                // 生成一个TCP的socket
                myDataRS.listServer.Add(listener);//添加到Socket集合
                listener.Bind(localEndPoint);
                listener.Listen(500);
                while (true)
                {
                    allDone.Reset();
                    listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);    //开启异步监听socket
                    // 让程序等待，直到连接任务完成。在AcceptCallback里的适当位置放置allDone.Set()语句.
                    allDone.WaitOne();
                }

Answer 7

listener.Stop();
thread.Abort();

Answer 8

listener.Stop();
listener没有stop()这个方法啊

Answer 9

我的停止按钮里写了,但是没用
            if (myDataRS.listthread.Count > 0)//关闭所有线程
            {
                foreach (Thread item in myDataRS.listthread)
                {
                    if (item.ThreadState == ThreadState.Running)
                    {
                        item.Abort();
                    }
                }
            }
            if (myDataRS.listServer.Count > 0)//关闭所有Socket
            {
                foreach (Socket item in myDataRS.listServer)
                {
                    item.Close();
                }
            }
            btnStopListen.Enabled = false;//还原
            btnStartListen.Enabled = true;//按钮
            myDataRS.listServer.Clear();//清空Socket集合
            myDataRS.listthread.Clear();//清空线程集合

Answer 10

我用异步监听接收的，就会报异常 
这句话
 listener.BeginAccept(new AsyncCallback(AcceptCallback), listener); //开启异步监听socket
无法访问已释放的对象。
对象名:“System.Net.Sockets.Socket”。

Answer 11

private ManualResetEvent allDone = new ManualResetEvent(false);
这是写在窗体类里的

Answer 12

        /// <summary>
        /// 监听按钮点击事件
        /// </summary>
        private void btnStartListen_Click(object sender, EventArgs e)
        {
            myDataRS.listI = myDataRS.GetAllInternet();//所有以太网信息
            if (myDataRS.listI.Count != 0)
            {
                IPAddress HostIP = IPAddress.Parse("127.0.0.1");//本机IP
                HostIP = IPAddress.Parse(txtIP.Text.Trim());//监听IP
                IPEndPoint ipep;//监听终端
                foreach (Internet item in myDataRS.listI)
                {
                    if (item.InetPRT == 1)//UDP
                    {
                        ipep = new IPEndPoint(IPAddress.Any, Convert.ToInt32(item.InetPort));//指定端口
                        Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
                        socket.Bind(ipep);//绑定端口
                        myDataRS.listServer.Add(socket);//添加到Socket集合
                        Thread thread = new Thread(new ParameterizedThreadStart(UdpAccept));//另开线程处理
                        thread.Start(socket);//开始线程
                        myDataRS.listthread.Add(thread);//添加到线程集合
                    }
                    else if (item.InetPRT == 2)//TCP
                    {
                        ipep = new IPEndPoint(HostIP, Convert.ToInt32(item.InetPort));//指定端口
                        Thread thread = new Thread(new ParameterizedThreadStart(StartListening));
                        thread.Start(ipep);//开始线程
                        myDataRS.listthread.Add(thread);//添加到线程集合
                    }
                }
                btnStartListen.Enabled = false;//开始监听按钮为不可用状态
                btnStopListen.Enabled = true;//停止按钮为可用状态
                StartTimeOneMinute();//定时器 间隔1分钟
                IsListen(true);
            }
            else
            {
                MessageBox.Show("没有设置以太网信息！", "提示");
            }
        }        /// <summary>
        /// 停止监听按钮点击事件
        /// </summary>
        private void btnStopListen_Click(object sender, EventArgs e)
        {
            if (myDataRS.listthread.Count > 0)//关闭所有线程
            {
                foreach (Thread item in myDataRS.listthread)
                {
                    if (item.ThreadState == ThreadState.Running)
                    {
                        item.Abort();
                    }
                }
            }
            if (myDataRS.listServer.Count > 0)//关闭所有Socket
            {
                foreach (Socket item in myDataRS.listServer)
                {
                    item.Close();
                }
            }
            btnStopListen.Enabled = false;//还原
            btnStartListen.Enabled = true;//按钮
            myDataRS.listServer.Clear();//清空Socket集合
            myDataRS.listthread.Clear();//清空线程集合
            List<Dev> list = new List<Dev>();
            list = myDataRS.GetAllConDevForCon();//获取所有连接状态设备
            if (list.Count != 0)
            {
                foreach (Dev item in list)
                {
                    myDataRS.UpdateDevCon(item.DevID, 0);//修改状态为中断
                }
            }
            IsListen(false);
        }
      /// <summary>
        /// 开始监听
        /// </summary>
        /// <param name="obj"></param>
        private void StartListening(object obj)
        {
            //try
            //{
                IPEndPoint localEndPoint = (IPEndPoint)obj;
                Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                // 生成一个TCP的socket
                myDataRS.listServer.Add(listener);//添加到Socket集合
                listener.Bind(localEndPoint);
                listener.Listen(500);
                while (true)
                {
                    allDone.Reset();
                    listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);    //开启异步监听socket
                    // 让程序等待，直到连接任务完成。在AcceptCallback里的适当位置放置allDone.Set()语句.
                    allDone.WaitOne();
                }
            //}
            //catch (Exception)//终止异步监听
            //{
            //}
        }        /// <summary>
        /// 读取行为的回调函数ReadCallback
        /// </summary>
        /// <param name="ar"></param>
        private void ReadCallback(IAsyncResult ar)
        {
            String content = String.Empty;
            Socket handler = null;
            try
            {
                StateObject state = (StateObject)ar.AsyncState; // 从异步state对象中获取state和socket对象.
                lock (state)
                {
                    handler = state.workSocket;
                    int bytesRead = handler.EndReceive(ar); // 从客户socket读取数据. 
                    IPEndPoint sender = (IPEndPoint)handler.RemoteEndPoint;//客户端IP
                    string GPRS_IP = sender.Address.ToString();
                    if (bytesRead > 0)
                    {
                        // 如果接收到数据，则存起来
                        state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
                        // 检查是否有结束标记，如果没有则继续读取
                        content = state.sb.ToString();
                        if (content.IndexOf("<EOF>") <= -1)
                        {
                            // 接收未完成，继续接收.
                            handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                            new AsyncCallback(ReadCallback), state);
                            string stringData = Encoding.ASCII.GetString(state.buffer, 0, bufferSize);//解码
                            DataProcess(stringData, GPRS_IP,handler, sender);
                        }
                    }
                    else
                    {
                        handler.Shutdown(SocketShutdown.Both);
                        handler.Close();
                        //throw(new Exception("读入的数据小于1bit"));
                    }
                }
            }
            catch (Exception)
            {
                handler.Close();//释放连接
                string devid = "";
                foreach (DictionaryEntry item in myDataRS.hashtable)
                {
                        object[] ob = (object[])item.Value;
                        if (ob[1].Equals(handler))//socket是否相等
                        {
                            devid = item.Key.ToString();
                            myDataRS.UpdateDevCon(devid, 0);
                        }
                        SetDataToConDev();
                }
                myDataRS.hashtable.Remove(devid);//移除该设备在表中的存储项
            }
        }                                                                                                                                                                                                                                                                                               /// <summary>
        /// 连接
        /// </summary>
        /// <param name="ar"></param>
        private void AcceptCallback(IAsyncResult ar)
        {
            Socket handler = null;
            try
            {
                Socket listener = (Socket)ar.AsyncState;// 获取客户请求的socket
                handler = listener.EndAccept(ar);
                StateObject state = new StateObject(bufferSize, handler); // 造一个容器，并用于接收命令.
                state.workSocket = handler;
                handler.BeginReceive(state.buffer, 0, bufferSize, 0, new AsyncCallback(ReadCallback), state);
              
            }
            catch (Exception)//终止异步监听
            {
            }
            finally
            {
                allDone.Set();  //添加此命令，让主线程继续.
            }
        }

Answer 13

        /// <summary>
        /// 读取行为的回调函数ReadCallback
        /// </summary>
        /// <param name="ar"></param>
        private void ReadCallback(IAsyncResult ar)  一直还在被调用  不懂异步  这是模仿来的代码

Answer 14

谁在访问 private void ReadCallback(IAsyncResult ar) 我怎么在你代码里没有找到？
把他的访问端停止掉。

Answer 15

        /// <summary>
        /// 连接
        /// </summary>
        /// <param name="ar"></param>
        private void AcceptCallback(IAsyncResult ar)
        {
            Socket handler = null;
            try
            {
                Socket listener = (Socket)ar.AsyncState;// 获取客户请求的socket
                handler = listener.EndAccept(ar);
                StateObject state = new StateObject(bufferSize, handler); // 造一个容器，并用于接收命令.
                state.workSocket = handler;
                handler.BeginReceive(state.buffer, 0, bufferSize, 0, new AsyncCallback(ReadCallback), state);
              
            }
            catch (Exception)//终止异步监听
            {
            }
            finally
            {
                allDone.Set();  //添加此命令，让主线程继续.
            }
        }

Answer 16

handler.Close()之后，想要再连，客户端就连不上了
说目标机积极拒绝