帮忙看看进程问题-----------------------------？

[kangbo818]

1.为什么窗口关闭后，进程还在



用了很多方法如Application.Exit（）和Application.ExitThread()都不行

2.Form类中定义一个类MyTCPServer，无法使用Form中得Listbox，说是不在进程中创建的Listbox，
怎么把这句话 Console.WriteLine("正在监听...") ;写在Listbox中

怎么实现，新手，写下代码。


代码如下：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Diagnostics;

namespace TcpService
{
    public partial class Form1 : Form
    {
        public delegate void SetThreadState(int nClientID);
        public static int nCountRecv = 0;
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            
        }


        /////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// socket服务器类，负责监听以及连接
        /// </summary>
        public class MyTCPServer
        {
            private int nListenPort = 4000;
            private int nMaxClient = 500;       //同时连接500个客户端
            private TcpListener tlTcpListen;
            private bool bIsListen = true;
            private Thread thAccept;
            MySocketProv[] RunSocketInfo;
            bool[] ThreadRun;

            public void DoStartIT()
            {
                try
                {
                    RunSocketInfo = new MySocketProv[nMaxClient]; //500个客户端数组
                    ThreadRun = new bool[nMaxClient];  //500个客户端状态数组

                    for (int i = 0; i < nMaxClient; i++)
                    {
                        ThreadRun[i] = false;
                        RunSocketInfo[i] = new MySocketProv();
                        RunSocketInfo[i].ThreadState = SetExitThread;
                    }

                    tlTcpListen = new TcpListener(nListenPort);    //以20812端口号来初始化TcpListener实例
                    tlTcpListen.Start();	//开始监听网络的连接请求
                    Console.WriteLine("正在监听...");


                    thAccept = new Thread(AcceptThread);
                    thAccept.Start();
                    

                }
                catch (System.Security.SecurityException)
                {
                    Console.WriteLine("侦听失败！错误");
                    Console.ReadLine();
                }

            }

            public void DoExitIT()
            {
                bIsListen = false;
                thAccept.Abort();
                tlTcpListen.Stop();

                for (int i = 0; i < nMaxClient; i++)
                {
                    if (ThreadRun[i])
                    {
                        RunSocketInfo[i].ExitThread();
                    }
                }
            }

            /// <summary>
            /// 获取当前空的 ID
            /// </summary>
            /// <returns></returns>
            private int GetEmptySocket()
            {
                int i = 0;
                for (i = 0; i < nMaxClient; i++)
                {
                    if (ThreadRun[i] == false)
                    {
                        break;
                    }
                }

                if (i == nMaxClient)
                {
                    return -1;
                }
                else
                {
                    return i;
                }
            }

            /// <summary>
            /// 接收线程
            /// </summary>
            private void AcceptThread()
            {
                while (bIsListen)
                {
                    int nSocketID = GetEmptySocket();
                    if (nSocketID != -1)
                    {
                        Console.WriteLine("启动监听 {0} ", nSocketID);
                        RunSocketInfo[nSocketID].nClientID = nSocketID;
                        RunSocketInfo[nSocketID].mSocket = tlTcpListen.AcceptSocket();
                        RunSocketInfo[nSocketID].bIsRunNow = true;


                        Console.WriteLine("已经连接！{0}", nSocketID);
                        ThreadRun[nSocketID] = true;

                        RunSocketInfo[nSocketID].DoStartRead();

                        //                     Thread workObject = new Thread(ThreadProv);
                        //                     workObject.Start();
                    }
                    else
                    {
                        Thread.Sleep(100);	//延时100ms 再尝试 -> 此时为已经满连接,等待中>>>>>
                    }
                }

                //////

            }

            private void SetExitThread(int nClientID)
            {
                ThreadRun[nClientID] = false;
            }

        }



        /////////////////////////////////////////////////////////////////////////////

[kangbo818]

        /// <summary>
        /// 每一个终端的处理，处理通讯协议以及状态管理
        /// </summary>
        public class MySocketProv
        {
            private int ClientID;
            private Socket SocketRW;
            private bool bIsRun;
            private Thread thProv;

            //申明委托实例
            private event SetThreadState SetExitState;
            // 
            //         public void OnExitState(int nClientID)
            //         {
            //             SetExitState(nClientID);
            //         }

            public int nClientID
            {
                get
                {
                    return ClientID;
                }
                set
                {
                    ClientID = value;
                }
            }

            public SetThreadState ThreadState
            {
                get
                {
                    return SetExitState;
                }
                set
                {
                    SetExitState = value;
                }
            }

            public Socket mSocket
            {
                get
                {
                    return SocketRW;
                }
                set
                {
                    SocketRW = value;
                }
            }

            public bool bIsRunNow
            {
                get
                {
                    return bIsRun;
                }

                set
                {
                    bIsRun = value;
                }
            }

            public void DoStartRead()
            {
                thProv = new Thread(ThreadProv);
                thProv.Start();
            }

            public void ExitThread()
            {
                bIsRun = false;
                thProv.Abort();
                SocketRW.Close();
            }

            private void ThreadProv()
            {
                EndPoint tempRemoteEP = SocketRW.RemoteEndPoint;
                IPEndPoint tempRemoteIP = (IPEndPoint)tempRemoteEP;	//获取请求的远程计算机名称
                IPHostEntry host = Dns.GetHostByAddress(tempRemoteIP.Address);
                string sHostName = host.HostName;
                string sTime = DateTime.Now.ToShortTimeString();

                while (bIsRun)
                {
                    try
                    {
                        //获取接收数据时的时间
                        Byte[] byRead = new Byte[2048];
                        // int iRead = stRead[0].Receive(byRead, ref tempRemoteEP);
                        int iRead = SocketRW.Receive(byRead); ;
                        if (iRead > 10000 || iRead == 0)
                        {
                            bIsRun = false;
                            Console.WriteLine("连接已经关闭！");
                        }
                        else
                        {
                            //获得接收的字节数目
                            Byte[] byText = new Byte[iRead];
                            //并根据接收到的字节数目来定义字节数组
                            Array.Copy(byRead, 0, byText, 0, iRead);
                            string sTemp = System.Text.Encoding.Default.GetString(byText);
                            //判断是否为断开连接控制码
                            if (sTemp.Trim() == "STOP")
                            {
                                SocketRW.Close();

                                //关闭侦听
                                Console.WriteLine("连接已经关闭！");

                                //中止线程
                                return;
                            }
                            else
                            {
                                Console.WriteLine("{0} - " + sTime + " " + sTemp + " - rcev: {1}", ClientID, nCountRecv++);
                                string strSendBuf;
                                strSendBuf = string.Format("Server: ask - {0}", ClientID);
                                // 
                                byte[] bySendBuf;
                                bySendBuf = new byte[100];
                                bySendBuf = Encoding.GetEncoding("gb2312").GetBytes(strSendBuf);
                                SocketRW.Send(bySendBuf);
                            }

                        }

                    }
                    //处理参数为空引用异常 
                    catch (ArgumentNullException ae)
                    {
                        bIsRun = false;
                        SetExitState(ClientID);
                        Console.WriteLine("ArgumentNullException : {0}", ae.ToString());
                        ExitThread();
                    }
                    //处理操作系统异常 
                    catch (SocketException se)
                    {
                        bIsRun = false;
                        SetExitState(ClientID);
                        Console.WriteLine("SocketException : {0}", se.ToString());
                        ExitThread();
                    }
                    catch (Exception e)
                    {
                        bIsRun = false;
                        SetExitState(ClientID);
                        Console.WriteLine("Unexpected exception : {0}", e.ToString());
                        ExitThread();
                    }
                }

            }
        }
        MyTCPServer myTCPServerDemo = new MyTCPServer();
        private void Form1_Load(object sender, EventArgs e)
        {
           
            statusBar1.Text = "1111111111";
            listBox1.Items.Add("欢迎光临");
            //MyTCPServer myTCPServerDemo = new MyTCPServer();
            myTCPServerDemo.DoStartIT();

            while (true);
            myTCPServerDemo.DoExitIT();
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            myTCPServerDemo.DoExitIT();
        }  
    }
}

[ztenv]

2.Form类中定义一个类MyTCPServer，无法使用Form中得Listbox，说是不在进程中创建的Listbox，
怎么把这句话 Console.WriteLine("正在监听...") ;写在Listbox中

要么在同一线程是创建MYTCPServer的实例，要么在更新界面数据的时候使用同步机制：
if(Listbox.InvokeRequired)
{
//listbox.invoke(新建更新委托，传入参数);
}else
{
//直接更新界面数据
}

[ztenv]

        private void Form1_Load(object sender, EventArgs e)
        {
           
            statusBar1.Text = "1111111111";
            listBox1.Items.Add("欢迎光临");
            //MyTCPServer myTCPServerDemo = new MyTCPServer();
            myTCPServerDemo.DoStartIT();

            while (true);//这一句有用吗？
            myTCPServerDemo.DoExitIT();
        }

[dancingbit]

1.还有资源没有彻底释放，MySocketProv是什么类型？TcpClient之类的需要Close并Dispose。
2.放置ListBox的Form中写一个public方法，接受数据并写入ListBox中，接收网络数据的线程中调用此方法。

[kangbo818]

那个没用，我想让myTCPServerDemo.DoExitIT()执行，不知道怎么执行，应该是再Form1_FormClosing中
但也不行

[wartim]

thAccept = new Thread(AcceptThread);
thAccept.IsBackground = true
thAccept.Start();

那把线程设置为后台好了，程序主线程退出，线程自动跟着结束

[kangbo818]

[Quote=引用 4 楼 dancingbit 的回复:]
1.还有资源没有彻底释放，MySocketProv是什么类型？TcpClient之类的需要Close并Dispose。
2.放置ListBox的Form中写一个public方法，接受数据并写入ListBox中，接收网络数据的线程中调用此方法。
[/Quote]

是单个线程，就是单个客户端，close了也不管用，线程老关不了，进程就关不了

[bbwolfcool]

控件是在线程安全的，1个控件在线程1创建，正常情况，不能被线程2访问

如果结束的时候，可能会回收不干净

可以尝试，在C# 里面直接结束 进程，注意是进程

[kangbo818]

还有我第一次运行时，窗口不出来，任务管理器中有进程会出现，
第二次运行就说套接字只允许一次，
为什么窗口不出来？？？？

[bentian1983]

在DoExitIT()方法设个断点，看看每次关项目时此方法的运行状态，理论上应该是在Form1_FormClosing或Form1_FormClosed里调关闭进程方法啊...

[kangbo818]

[Quote=引用 6 楼 wartim 的回复:]
thAccept = new Thread(AcceptThread);
thAccept.IsBackground = true
thAccept.Start();

那把线程设置为后台好了，程序主线程退出，线程自动跟着结束
[/Quote]

用这个会出现异常

[dancingbit]

就我遇到的情况来说，涉及到网络操作的程序，进程不能结束，基本上就是因为资源没有释放干净。虽然表面上来看，执行了Close和Dispose，事实上，可能因为某些意外，相关资源并没有真正释放。甚至于是因为程序中不恰当的try...catch使用某些操作被跳过。

[kangbo818]

[Quote=引用 9 楼 kangbo818 的回复:]
还有我第一次运行时，窗口不出来，任务管理器中有进程会出现，
第二次运行就说套接字只允许一次，
为什么窗口不出来？？？？
[/Quote]

这个是为什么啊？？？

[happyboyxq]

个人觉得，可能是关闭窗体的时候while循环在执行，可以试下
while(true)
{
try{}
catch
{
//此处添加break,遇到错误时跳出循环，再执行线程关闭。
break;
}
}

[hecker728]

[Quote=引用 9 楼 kangbo818 的回复:]
还有我第一次运行时，窗口不出来，任务管理器中有进程会出现，
第二次运行就说套接字只允许一次，
为什么窗口不出来？？？？
[/Quote]

还有我第一次运行时，窗口不出来，任务管理器中有进程会出现，
线程阻塞或异常，，调试跟踪
第二次运行就说套接字只允许一次，
资源没有完全释放
为什么窗口不出来？？？？

            public void ExitThread()
            {
                bIsRun = false;
                thProv.Abort();//这个不能这样用，这条语句会引发ThreadAbortException
                SocketRW.Close();
            }

//应该这样

            public void ExitThread()
            {
　　　　　　　　　try
               {
                thProv.Abort();
               }
               catch(ThreadAbortException e)
               {
                 bIsRun = false;
                 SocketRW.Close();
               }              
            }

可能你的代码还有其他的原因，好好调试下。