c#服务器管理程序

namespace Servers
{
    class Server:TCPFrameHandle
    {
        // Thread signal.
        public ManualResetEvent allDone = new ManualResetEvent(false);
        Form1 m_mainwnd = null;
        //private Socket handler = null;
        public ArrayList m_CliSocketArr = new ArrayList();
        private string m_ServerIP;
        private int m_ServerPort;
        private static Object thisLock = new Object();
        Socket listener = null;
        Thread listenThread = null;
        Thread workerThread = null;
        bool IsThreadOpen = false;
        public Server(Form1 mainwnd,string ServerIP = "192.168.0.112", int SerPort = 8080)
        {
            m_ServerIP = ServerIP;
            m_ServerPort = SerPort;
            m_mainwnd = mainwnd;
            //InitServerSocket(ServerIP,SerPort);
            //InitThread();
        }
        /// <summary>
        /// 初始化套接字
        /// </summary>
        /// <param name="ServerIP"></param>
        /// <param name="SerPort"></param>
        private void InitServerSocket(string ServerIP, int SerPort)
        {
            IPAddress ipAddress = IPAddress.Parse(ServerIP);//
            IPEndPoint localEndPoint = new IPEndPoint(ipAddress, SerPort);
            // Create a TCP/IP socket.
            listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            listener.Bind(localEndPoint);
            listener.Listen(100);
            // Start an asynchronous socket to listen for connections.
            Console.WriteLine("Waiting for a connection...");
            InformationShow("Waiting for a connection...");
        }
        /// <summary>
        /// 初始化线程
        /// </summary>
        private void InitThread()
        {
            workerThread = null;
            listenThread = null;
            listenThread = new Thread(new ThreadStart(ListeningThread));
            listenThread.Name = "listenThread";
            listenThread.IsBackground = true;
            workerThread = new Thread(new ThreadStart(WorkingThread));//创建一个线程用于处理请求
            workerThread.Name = "workerThread";
            workerThread.IsBackground = true;
            
            ThreadPool.SetMaxThreads(int.MaxValue, int.MaxValue);
        }
        /// <summary>
        /// 启动服务器
        /// </summary>
        public void StartServer()
        {
            if (!IsThreadOpen)
            {
                listener = null;
                InitServerSocket(m_ServerIP,m_ServerPort);
                InitThread();
                //m_CliSocketArr = new ArrayList();
                workerThread.Start();
                listenThread.Start();
            }           
        }
        /// <summary>
        /// 停止服务器
        /// </summary>
        public void StopServer()
        {
            //IsThreadOpen = false;
            if (listener!=null)
            {
                listener.Close();
                listener.Dispose();
                listener = null;


                workerThread.Abort();
                listenThread.Abort();
                workerThread = null;
                listenThread = null;
                foreach (Socket socket in m_CliSocketArr)
                {
                    socket.Shutdown(SocketShutdown.Both);
                    socket.Close();
                }
                m_CliSocketArr.Clear();
            }   
           
        }
      
        /// <summary>
        /// 由套接字获取IP地址
        /// </summary>
        /// <param name="sClient"></param>
        /// <returns></returns>
        private IPAddress GetIPAddress(Socket sClient)
        {
            return ((IPEndPoint)sClient.RemoteEndPoint).Address;
        }
        /// <summary>
        /// 由套接字获取端口号
        /// </summary>
        /// <param name="sClient"></param>
        /// <returns></returns>
        private int GetPort(Socket sClient)
        {
            return ((IPEndPoint)sClient.RemoteEndPoint).Port;
        }
        /// <summary>
        /// 监听套接字线程
        /// </summary>
        public void ListeningThread()
        {
            // Bind the socket to the local endpoint and listen for incoming connections.
            try
            {
                while (true)
                {
                    Socket sClient = listener.Accept();


                    Console.WriteLine("There is a new connection." +
                        GetIPAddress(sClient).ToString() + ":" +
                        GetPort(sClient).ToString());
                    InformationShow("There is a new connection." +
                        GetIPAddress(sClient).ToString() + ":" +
                        GetPort(sClient).ToString());
                    lock(thisLock)
                    {
                        if (!m_CliSocketArr.Contains(sClient))
                        {
                            m_CliSocketArr.Add(sClient);
                            Console.WriteLine("There is " + m_CliSocketArr.Count.ToString() + " connection now.");
                            InformationShow("There is " + m_CliSocketArr.Count.ToString() + " connection now.");
                        }
                    }
                   
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }
        /// <summary>
        /// 接收数据线程
        /// </summary>
        /// 
        //Socket socketWorker = null;
        public void WorkingThread() 
        {
            Socket socketWorker = null;
            ArrayList readList = new ArrayList();
            while (true)
            {
                lock (thisLock)   //线程同步
                {
                    readList.Clear();
                    for (int i = 0; i < m_CliSocketArr.Count; i++)
                    {
                        readList.Add(m_CliSocketArr[i]);
                    }
                }
                //Socket sClient = listener.Accept();
                //Console.WriteLine("There is a new connection.");
                //m_CliSocketArr.Add(sClient);
                //如果没有套接字，服务器等待
                if (readList.Count <= 0)
                {
                    Thread.Sleep(100);
                    continue;
                }
                try
                {
                    Socket.Select(readList, null, null, 10);
                    for (int i = 0; i < readList.Count; i++)
                    {
                        socketWorker = (Socket)readList[i];
                        //Console.WriteLine("There is a new message from client.");
                        //InformationShow("There is a new message from client.");


                        byte[] buffer = new byte[1024];
                        int recLen = 0;
                        int maxnum = 1000;  //最多循环1000次，防止死循环
                        for (int j = 0; j < maxnum; j++)
                        {
                            Array.Clear(buffer, 0, buffer.Length);
                            recLen = socketWorker.Receive(buffer);
                            if (IsSockWorkerOK(socketWorker, recLen))
                            {
                                List<byte> recvOneFrameList = RecveOneFrame(buffer);
                                if (recvOneFrameList.Count > 0) //接收到完整一帧
                                {
                                    //Array.Clear(buffer, 0, buffer.Length);
                                    ClientUserParam param = new ClientUserParam(socketWorker,recvOneFrameList.ToArray(), recvOneFrameList.Count);
                                    ThreadPool.QueueUserWorkItem(new WaitCallback(ClientUserWorkThread), param);   //线程池分出一个线程
                                    break;
                                }
                                else                         //还没有接收完整一帧，继续接收
                                {
                                    continue;
                                }
                            } 
                            else
                            {
                                break;
                            }
                        }


                       // socketWorker.Send(buffer, recLen, SocketFlags.None);
                    }
                }
                catch (SocketException e)
                {
                    Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode);
                    for (int ii = 0; ii < m_CliSocketArr.Count; ii++)
                    {
                        Socket s = (Socket)m_CliSocketArr[ii];
                        if (s == socketWorker)
                        {
                            m_CliSocketArr.RemoveAt(ii);
                            Console.WriteLine("Remove a connection.");
                            InformationShow("Remove a connection.");
                            InformationShow("there are "+ GetConnectCount().ToString()+" connection now." );
                        }   
                    }
                    socketWorker.Shutdown(SocketShutdown.Both);
                    socketWorker.Close();
                }
            }


        }
        /// <summary>
        /// socketWorker.Receive(buffer)后判断套接字是否正常，返回值大于零正常，小于等于零不正常
        /// </summary>
        /// <param name="socketWorker"></param>
        /// <param name="recLen"></param>
        /// <returns></returns>
        private bool IsSockWorkerOK(Socket socketWorker, int recLen)
        {
            if (recLen > 0)
            {
                Console.WriteLine("message recieve sucess.");
                InformationShow("message recieve sucess.");
            }
            else
            {//如果返回0，表示客户端已经断开连接，须将此socket关闭然后从连接池中清除
                Console.WriteLine("Rece 0 length.Socket Disconnect");
                for (int ii = 0; ii < m_CliSocketArr.Count; ii++)
                {
                    Socket s = (Socket)m_CliSocketArr[ii];
                    if (s == socketWorker)
                    {
                        m_CliSocketArr.RemoveAt(ii);
                        Console.WriteLine("Remove a connection.");
                        InformationShow("Remove a connection.");
                        InformationShow("there are " + GetConnectCount().ToString() + " connection now.");
                    }
                }
                socketWorker.Shutdown(SocketShutdown.Both);
                socketWorker.Close();
                return false;
            }
            return true;
        }
        /// <summary>
        /// 获得连接的客户端套接字的个数
        /// </summary>
        /// <returns></returns>
        public int GetConnectCount()
        {
            return m_CliSocketArr.Count;
        }


        delegate void BD_NETThreadHandle();                //委托声明
        /// <summary>
        /// 解析线程--由线程池分出
        /// </summary>
        /// <param name="obj"></param>
        private void ClientUserWorkThread(object obj)
        {
            ClientUserParam param = (ClientUserParam)obj;
            byte[] recievebuf = param.buf;
            int datalen = param.datalen;
            byte[] buftemp = new byte[datalen];
            Array.Copy(recievebuf, buftemp, datalen);
            string text = Encoding.Default.GetString(buftemp);
            Console.WriteLine(text);
            InformationShow(text);
            lock(thisLock)
            {
                foreach (Socket sock in m_CliSocketArr)
                {
                    sock.Send(buftemp);
                }
            }
        }
        /// <summary>
        /// 主窗口显示信息
        /// </summary>
        /// <param name="text"></param>
        private void InformationShow(string text)
        {
            BD_NETThreadHandle a = delegate()
            {
                m_mainwnd.textBoxShow.AppendText(text+"\n");
            };
            m_mainwnd.textBoxShow.Invoke(a);
        }
    }
    /// <summary>
    /// 线程池传参数
    /// </summary>
    class ClientUserParam
    {
        public byte[] buf;
        public int datalen;
        public Socket socktWorker;
        public ClientUserParam(Socket sockWorker,byte[] buff, int datalength)
        {
            socktWorker = sockWorker;
            buf = buff;
            datalen = datalength;
        }
    }
}