C#停止异步监听问题

Question

求高人相助
      /// <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)
        {
            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();
            }
        }        /// <summary>
        /// 读取行为的回调函数ReadCallback
        /// </summary>
        /// <param name="ar"></param>
        private void ReadCallback(IAsyncResult ar)
        {
            String content = String.Empty;
            Socket handler = null;
            try
            {
                lock (ar)
                {
                    StateObject state = (StateObject)ar.AsyncState; // 从异步state对象中获取state和socket对象.
                    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
                if (listener.Connected)
                {
                    handler = listener.EndAccept(ar);
                    StateObject state = new StateObject(bufferSize, handler); // 造一个容器，并用于接收命令.
                    state.workSocket = handler;
                    handler.BeginReceive(state.buffer, 0, bufferSize, 0, new AsyncCallback(ReadCallback), state);
                }
            }
            finally
            {
                allDone.Set();  //添加此命令，让主线程继续.
            }
        }        /// <summary>
        /// Tcp发送
        /// </summary>
        /// <param name="str">参数数组</param>
        private void TcpSend(string[] str)
        {
            object[] obj = (object[])myDataRS.hashtable[str[2]];//通过设备编号找到myDataRS.hashtable中的值
            Socket socket = (Socket)obj[1];
            string data = myDataRS.CreateSendData(str);
            byte[] sendbuf = Encoding.ASCII.GetBytes(data);
            try
            {
                socket.Send(sendbuf);
            }
            catch (Exception)
            {
                MessageBox.Show("该设备已经短裤");
            }
           
        }tcp/ip用的是异步监听  停止监听按钮后，错误提示
无法访问已释放的对象。
对象名:“System.Net.Sockets.Socket”。求，怎么停止异步监听

Answer 1

tcp/ip用的是异步监听 停止监听按钮后，错误提示
无法访问已释放的对象。
对象名:“System.Net.Sockets.Socket”。求，怎么停止异步监听
求高人！！！

Answer 2

从代码中看,你知道通过alldone这样的Event做同步控制,那么也应该知道在线程里通过Event同步来正常结束线程,而不是通过Abort去强制结束.而且在线程正常对出之前,你可以很优雅的释放掉你的listener这个socket,而不需要在Stop按钮中强制去Close.

Answer 3

                newclient.Shutdown(SocketShutdown.Both);
                newclient.Close();