TCP服务端

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

namespace TCPServer
{
    public partial class Form1 : Form
    {
        
        Thread threadWatch = null; // 负责监听客户端连接请求的 线程；
        Socket socketWatch = null;
        Dictionary<string, Socket> dict = new Dictionary<string, Socket>();//存放套接字
        Dictionary<string, Thread> dictThread = new Dictionary<string, Thread>();//存放线程
        public Form1()
        {
            //有时候会遇到窗体间的控件访问异常，需要这样处理
            Control.CheckForIllegalCrossThreadCalls=false;
            InitializeComponent();
        }

        private void Connect_Click(object sender, EventArgs e)
        {
            // 创建负责监听的套接字，注意其中的参数；
            socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            // 获得文本框中的IP对象；
            IPAddress address = IPAddress.Parse(tbx_IP.Text.Trim());
            // 创建包含ip和端口号的网络节点对象；
            IPEndPoint endPoint = new IPEndPoint(address, int.Parse(tbxPort.Text.Trim()));
            try
            {
                // 将负责监听的套接字绑定到唯一的ip和端口上；
                socketWatch.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
                socketWatch.Bind(endPoint);
            }
            catch (SocketException se)
            {
                MessageBox.Show("异常：" + se.Message);
                return;
            }
            // 设置监听队列的长度；
            socketWatch.Listen(10000);
            // 创建负责监听的线程；
            threadWatch = new Thread(WatchConnecting);
            threadWatch.IsBackground = true;
            threadWatch.Start();
            Messages(tbx_Show,"服务器启动监听成功！");
        }
        /// <summary>
        /// 监听客户端请求的方法；
        /// </summary>
        void WatchConnecting()
        {
            Messages(tbx_Show, "新客户端连接成功！");
            while (true)  // 持续不断的监听客户端的连接请求；
            {
                // 开始监听客户端连接请求，Accept方法会阻断当前的线程；
                Socket sokConnection = socketWatch.Accept(); // 一旦监听到一个客户端的请求，就返回一个与该客户端通信的 套接字；
                var ssss = sokConnection.RemoteEndPoint.ToString().Split(':');
                //查找ListBox集合中是否包含此IP开头的项，找到为0，找不到为-1
                if (lbOnline.FindString(ssss[0]) >= 0)
                {
                    lbOnline.Items.Remove(sokConnection.RemoteEndPoint.ToString());
                }
                else
                {
                    lbOnline.Items.Add(sokConnection.RemoteEndPoint.ToString());
                }
                // 将与客户端连接的 套接字 对象添加到集合中；
                dict.Add(sokConnection.RemoteEndPoint.ToString(), sokConnection);
                Thread thr = new Thread(RecMsg);
                thr.IsBackground = true;
                thr.Start(sokConnection);
                dictThread.Add(sokConnection.RemoteEndPoint.ToString(), thr);  //  将新建的线程 添加 到线程的集合中去。
            }
//        }

//         public virtual bool ProcessReceive(byte[] buffer, int offset, int count) //接收异步事件返回的数据，用于对数据进行缓存和分包  
//{  
//    m_activeDT = DateTime.UtcNow;  
//    DynamicBufferManager receiveBuffer = m_asyncSocketUserToken.ReceiveBuffer;  
  
//    receiveBuffer.WriteBuffer(buffer, offset, count);  
//    if (receiveBuffer.DataCount > sizeof(int))  
//    {  
//        //按照长度分包  
//        int packetLength = BitConverter.ToInt32(receiveBuffer.Buffer, 0); //获取包长度  
//        if (NetByteOrder)  
//            packetLength = System.Net.IPAddress.NetworkToHostOrder(packetLength); //把网络字节顺序转为本地字节顺序  
  
  
//        if ((packetLength > 10 * 1024 * 1024) | (receiveBuffer.DataCount > 10 * 1024 * 1024)) //最大Buffer异常保护  
//            return false;  
  
//        if ((receiveBuffer.DataCount - sizeof(int)) >= packetLength) //收到的数据达到包长度  
//        {  
//            bool result = ProcessPacket(receiveBuffer.Buffer, sizeof(int), packetLength);  
//            if (result)  
//                receiveBuffer.Clear(packetLength + sizeof(int)); //从缓存中清理  
//            return result;  
//        }  
//        else  
//        {  
//            return true;  
//        }  
//    }  
//    else  
//    {  
//        return true;
//    }
}  
            //解包
//            public virtual bool ProcessPacket(byte[] buffer, int offset, int count) //处理分完包后的数据，把命令和数据分开，并对命令进行解析  
//{  
//    if (count < sizeof(int))  
//        return false;  
//    int commandLen = BitConverter.ToInt32(buffer, offset); //取出命令长度  
//    string tmpStr = Encoding.UTF8.GetString(buffer, offset + sizeof(int), commandLen);  
//    if (!m_incomingDataParser.DecodeProtocolText(tmpStr)) //解析命令  
//      return false;  
  
//    return ProcessCommand(buffer, offset + sizeof(int) + commandLen, count - sizeof(int) - commandLen); //处理命令  
//}  

//            public bool DecodeProtocolText(string protocolText)  
//{  
//    m_header = "";  
//    m_names.Clear();  
//    m_values.Clear();  
//    int speIndex = protocolText.IndexOf(ProtocolKey.ReturnWrap);  
//    if (speIndex < 0)  
//    {  
//        return false;  
//    }  
//    else  
//    {  
//        string[] tmpNameValues = protocolText.Split(new string[] { ProtocolKey.ReturnWrap }, StringSplitOptions.RemoveEmptyEntries);  
//        if (tmpNameValues.Length < 2) //每次命令至少包括两行  
//            return false;  
//        for (int i = 0; i < tmpNameValues.Length; i++)  
//        {  
//            string[] tmpStr = tmpNameValues[i].Split(new string[] { ProtocolKey.EqualSign }, StringSplitOptions.None);  
//            if (tmpStr.Length > 1) //存在等号  
//            {  
//                if (tmpStr.Length > 2) //超过两个等号，返回失败  
//                    return false;  
//                if (tmpStr[0].Equals(ProtocolKey.Command, StringComparison.CurrentCultureIgnoreCase))  
//                {  
//                    m_command = tmpStr[1];  
//                }  
//                else  
//                {  
//                    m_names.Add(tmpStr[0].ToLower());  
//                    m_values.Add(tmpStr[1]);  
//                }  
//            }  
//        }  
//        return true;  
//    }  
//}  
        void RecMsg(object sokConnectionparn)
        {
            Socket sokClient = sokConnectionparn as Socket;
            while (true)
            {
                // 定义一个缓存区；
                byte[] arrMsgRec = new byte[1024];
                // 将接受到的数据存入到输入  arrMsgRec中；
                int length = -1;
                try
                {
                    length = sokClient.Receive(arrMsgRec); // 接收数据，并返回数据的长度；
                    if (length > 0)
                    {
                        //主业务
                        Messages(tbx_Show,BitConverter.ToString(arrMsgRec));
                    }
                    else
                    {
                        // 从 通信套接字 集合中删除被中断连接的通信套接字;
                        dict.Remove(sokClient.RemoteEndPoint.ToString());
                        // 从通信线程集合中删除被中断连接的通信线程对象;
                        dictThread.Remove(sokClient.RemoteEndPoint.ToString());
                        // 从列表中移除被中断的连接IP
                        lbOnline.Items.Remove(sokClient.RemoteEndPoint.ToString());
                         Messages(tbx_Show,"" + sokClient.RemoteEndPoint.ToString() + "断开连接\r\n");
                        //log.log("遇见异常"+se.Message);
                        break;
                    }
                }
                catch (SocketException se)
                {
                    // 从 通信套接字 集合中删除被中断连接的通信套接字;
                    dict.Remove(sokClient.RemoteEndPoint.ToString());
                    // 从通信线程集合中删除被中断连接的通信线程对象;
                    dictThread.Remove(sokClient.RemoteEndPoint.ToString());
                    // 从列表中移除被中断的连接IP
                    lbOnline.Items.Remove(sokClient.RemoteEndPoint.ToString());
                     Messages(tbx_Show,"" + sokClient.RemoteEndPoint.ToString() + "断开,异常消息：" + se.Message + "\r\n");
                    //log.log("遇见异常"+se.Message);
                    break;
                }
                catch (Exception e)
                {
                    // 从 通信套接字 集合中删除被中断连接的通信套接字;
                    dict.Remove(sokClient.RemoteEndPoint.ToString());
                    // 从通信线程集合中删除被中断连接的通信线程对象;
                    dictThread.Remove(sokClient.RemoteEndPoint.ToString());
                    // 从列表中移除被中断的连接IP
                    lbOnline.Items.Remove(sokClient.RemoteEndPoint.ToString());
                    Messages(tbx_Show,"异常消息：" + e.Message + "\r\n");
                    // log.log("遇见异常" + e.Message);
                    break;
                }
            }
        }                    
        private void Form1_Load(object sender, EventArgs e)
        {
            //获取本地的IP地址
            string AddressIP = string.Empty;
            foreach (IPAddress _IPAddress in Dns.GetHostEntry(Dns.GetHostName()).AddressList)
            {
                if (_IPAddress.AddressFamily.ToString() == "InterNetwork")
                {
                    AddressIP = _IPAddress.ToString();
                }
            }
            //给IP控件赋值
            tbx_IP.Text = AddressIP;
        }
        public delegate void MessageDelegate(TextBox txtbox, string Messages);//委托文本框
        //文本框Invoke方法需要创建一个委托。你可以事先写好函数和与之对应的委托
        private void Messages(TextBox txtbox, string message)
        {
            if (txtbox.InvokeRequired)//示调用方在对控件进行方法调用时是否必须调用 Invoke 方法，因为调用方位于创建控件所在的线程以外的线程中。
            {
                MessageDelegate showMessageDelegate = Messages;
                txtbox.Invoke(showMessageDelegate, new object[] { txtbox, message });
            }
            else
            {
                tbx_Show.Text += message + "\r\n";
            }
        }

        //TcpClient tcpClient = (TcpClient)client;  
        //    NetworkStream networkStream = tcpClient.GetStream();  
        //    BinaryReader br = new BinaryReader(networkStream);  
        //    BinaryWriter bw = new BinaryWriter(networkStream);  
        //    while (true)  
        //    {  
        //        try  
        //        {  
        //            string sReader = br.ReadString(); //接收消息  
        //            Console.WriteLine(sReader); //打印消息  
        //            string sWriter = "接收到消息";  
        //            bw.Write(sWriter);   //向对方发送消息  
        //        }  
        //        catch  
        //        {  
        //            break;  
        //        }  
        //    }  
        //}  
        //static void Main()  
        //{  
        //    Program p = new Program();  
        //    IPAddress localAddress;      //IP地址  
        //    int port = 51888;     //端口  
        //    TcpListener tcpListener;  //监听套接字  
        //    TcpClient tcpClient;       
        //    IPAddress[] listenIp = Dns.GetHostAddresses("127.0.0.1");  
        //    localAddress = listenIp[0];  
        //    tcpListener = new TcpListener(localAddress, port);  
        //    tcpListener.Start(); //开始监听  
        //    while (true)  
        //    {  
        //        try  
        //        {  
        //            tcpClient = tcpListener.AcceptTcpClient();//每接受一个客户端则生成一个TcpClient  
        //            Thread thread = new Thread(p.ProcessConnection); //用一个线程单独处理这个连接  
        //            thread.Start(tcpClient);  
        //        }  
        //        catch  
        //        {  
        //            break;  
        //        }  
        //    }  
        //}  
    }
}