C# Winform Soket 网络编程 多个客户端连接服务器并返回客户端操作请求

2017.8.2 

服务器：

#region 参数与集合
        /// <summary>
        /// 客户端IP
        /// </summary>
        string clientIP;
        /// <summary>
        /// IP地址(IPAddress)
        /// </summary>
        string thisIp;
        /// <summary>
        /// 端口(Port)
        /// </summary>
        int port;
        /// <summary>
        /// Thread：监听客户端连接请求
        /// </summary>
        Thread watchClientThread = null;
        /// <summary>
        /// Socket：监听客户端连接请求
        /// </summary>
        Socket watchClientSocker = null;
        /// <summary>
        /// 套接字集合(Socket Gether)
        /// </summary>
        Dictionary<string, Socket> dictSocket = new Dictionary<string, Socket>();
        /// <summary>
        /// 线程集合(Thread Gether)
        /// </summary>
        Dictionary<string, Thread> dictThread = new Dictionary<string, Thread>(); 
        #endregion

        #region 获取本地IP地址
        /// <summary>
        /// 获取本地IP地址
        /// </summary>
        private void GetIPAddress()
        {
            NetworkInterface[] nis = NetworkInterface.GetAllNetworkInterfaces();
            if (nis.Length > 0)
            {
                for (int i = 0; i < nis.Length; i++)
                {
                    foreach (var item in nis[i].GetIPProperties().UnicastAddresses)
                    {
                        string s = item.Address.ToString();
                        string[] ss = s.Split('.');
                        if (ss.Length == 4)
                        {
                            if (ss[0].ToString() != "127" && ss[0].ToString() == "192")
                            {
                                thisIp = s;
                                break;
                            }
                        }
                    }
                }
            }
        }
        #endregion

        #region 启动服务器
        /// <summary>
        /// 启动服务器
        /// </summary>
        public void SocketStart()
        {
            GetIPAddress();
            port = 8888;
            watchClientSocker = new Socket(AddressFamily.InterNetwork,
                SocketType.Stream,
                ProtocolType.Tcp);
            IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(thisIp), port);
            try
            {
                watchClientSocker.Bind(endPoint);
            }
            catch (SocketException se)
            {
                rtbMonitoring.Text += "异常：" + se.Message + "
";
                return;
            }
            catch (Exception ex)
            {
                 rtbMonitoring.Text += "异常：" + ex.Message + "
";
            }
            watchClientSocker.Listen(50);
            watchClientThread = new Thread(WatchConnection);
            watchClientThread.IsBackground = true;
            watchClientThread.Start();
        }
        #endregion

        #region 开始监听客户端连接请求
        /// <summary>
        /// 开始监听客户端连接请求
        /// </summary>
        void WatchConnection()
        {
            while (true)
            {
                Socket socketConn = watchClientSocker.Accept();
                clientIP = socketConn.RemoteEndPoint.ToString();
                dictSocket.Add(clientIP, socketConn);
                Thread thr = new Thread(ReccptionData);
                thr.IsBackground = true;
                thr.Start(socketConn);
                dictThread.Add(clientIP, thr);
                 rtbMonitoring.Text += clientIP + " 连接成功" + "
"; 
            }
        }
        #endregion

        #region 客户端信息处理
        /// <summary>
        /// 客户端信息处理
        /// </summary>
        /// <param name="socketConn"></param>
        void ReccptionData(object socketConn)
        {
            Socket socketClient = socketConn as Socket;
            while (true)
            {
                byte[] arrRec = new byte[1024 * 1024 * 6];
                int length = -1;
                try
                {
                    length = socketClient.Receive(arrRec);
                }
                catch (SocketException se)
                {
                     rtbMonitoring.Text += "异常：" + se.Message+"
";
                    dictSocket.Remove(socketClient.RemoteEndPoint.ToString());
                    dictThread.Remove(socketClient.RemoteEndPoint.ToString());
                    break;
                }
                if (arrRec[0] == 0)
                {
                    clientIP = socketClient.RemoteEndPoint.ToString();
                    string strMsg = System.Text.Encoding.UTF8.GetString(arrRec, 1, length - 1);// 将接受到的字节数据转化成字符串；
                    ReturnData(strMsg);
                     rtbMonitoring.Text +=clientIP+"："+ strMsg + "
";
                }
                if (arrRec[0] == 1)
                {
                    if (!Directory.Exists("FileInfo"))
                    {
                        Directory.CreateDirectory("FileInfo");
                    }
                    if (!File.Exists(arrRec + ".txt"))
                    {
                        File.Create(arrRec + ".txt");
                    }
                    string fileSavePath = arrRec + " .txt";
                    using (FileStream fs = new FileStream(fileSavePath, FileMode.Create))
                    {
                        fs.Write(arrRec, 1, length - 1);
                         rtbMonitoring.Text += "文件保存成功：" + fileSavePath + "
";

                    }
                }
            }

        }
        #endregion

        #region 返回请求数据
        /// <summary>
        /// 返回请求数据
        /// </summary>
        /// <param name="data"></param>
        void ReturnData(string data)
        {
            string connectSql = "server=.;database=Thread_SocketDB;uid=sa;pwd=sa;";
            string strMsg;
            UserInfo u = new UserInfo();
            GetSql getsql = new GetSql();
            List<UserInfo> us = new List<UserInfo>();
            string[] datas = data.Split('/');
            string operationType = "";
            string type = "";
            string userName = "";
            string pwd = "";
            if (datas.Length > 4)
            {
                operationType = datas[1];
                type = datas[2];
                userName = datas[3];
                pwd = datas[4];
            }
            switch (operationType)
            {
                case "用户":
                    switch (type)
                    {
                        case "登录":
                            SqlConnection con = new SqlConnection(connectSql);
                            con.Open();
                            SqlCommand com = new SqlCommand(getsql.GetSelectAll(), con);
                            SqlDataReader dr = com.ExecuteReader();
                            while (dr.Read())
                            {
                                u = new UserInfo();
                                u.UserName = dr["UserName"].ToString();
                                u.Pwd = dr["Pwd"].ToString();
                                us.Add(u);
                            }
                            dr.Close();
                            con.Close();
                            strMsg = "正在验证登录信息...";
                            SendContent(strMsg);
                            List<UserInfo> loginInfo = us.FindAll((p) =>
                                p.UserName == userName);
                            if (loginInfo.Count <= 0)
                            {
                                strMsg = "对不起，你的账号不存在！";
                                SendContent(strMsg);

                            }
                            else
                            {
                                foreach (UserInfo userInfo in loginInfo)
                                {
                                    u = userInfo;
                                }

                                if (pwd != u.Pwd)
                                {

                                    strMsg = "对不起，你的密码不正确！";
                                    SendContent(strMsg);

                                }
                                else
                                {
                                    strMsg = "登录成功！";
                                    SendContent(strMsg);
                                }
                            }
                            break;
                        case "编号查询":

                            break;
                    }
                    break;
                case "管理员":

                    break;
            }
        }
        #endregion

        #region 封装发送信息
        /// <summary>
        /// 封装发送信息
        /// </summary>
        /// <param name="strMsg"></param>
        private void SendContent(string s)
        {
            byte[] arrMsg = System.Text.Encoding.UTF8.GetBytes(s);
            byte[] arrSendMsg = new byte[arrMsg.Length + 1];
            arrSendMsg[0] = 0; // 用来表示发送的是消息数据 
            Buffer.BlockCopy(arrMsg, 0, arrSendMsg, 1, arrMsg.Length);
            dictSocket[clientIP].Send(arrSendMsg);
        }
        #endregion

客户端：

 /// <summary>
        /// 客户端套接字对象
        /// </summary>
        Socket sockClient = null;
        /// <summary>
        /// 客户端线程
        /// </summary>
        Thread threadCilent = null;
        #region 开始连接字符串
        /// <summary>
        /// 开始连接字符串
        /// </summary>
        public void ServerConnect()
        {
            try
            {
                IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse("192.168.4.186"), 8888);
                sockClient = new Socket(AddressFamily.InterNetwork,
                    SocketType.Stream,
                    ProtocolType.Tcp);
                try
                {
                    lbReception.Text = "正在与服务器进行连接...
";
                    sockClient.Connect(endPoint);
                }
                catch (SocketException se)
                {
                    lbReception.Text = "异常：" + se.Message + "
";
                    return;
                }
                lbReception.Text = "连接成功！";
                threadCilent = new Thread(Res);
                threadCilent.IsBackground = true;
                threadCilent.Start();

            }
            catch (Exception)
            {
                lbReception.Text = "IP无效！";
                throw;
            }


        }

        #region 接收数据处理
        /// <summary>
        /// 接收数据处理
        /// </summary>
        private void Res()
        {

            while (true)
            {
                // 定义一个2M的缓存区； 
                byte[] arrMsgRec = new byte[1024 * 1024 * 6];
                // 将接受到的数据存入到输入 arrMsgRec中； 
                int length = -1;
                try
                {
                    length = sockClient.Receive(arrMsgRec); // 接收数据，并返回数据的长度； 
                }
                catch (SocketException se)
                {
                    lbReception.Text = "异常；" + se.Message;
                    return;
                }
                catch (Exception e)
                {
                    lbReception.Text = "异常：" + e.Message;
                    return;
                }
                if (arrMsgRec[0] == 0) // 表示接收到的是消息数据； 
                {
                    string strMsg = System.Text.Encoding.UTF8.GetString(arrMsgRec, 1, length - 1);// 将接受到的字节数据转化成字符串； 
                    lbReception.Text = strMsg;
                }
            }
        } 
        #endregion
        #endregion

        #region 发送数据
        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="s"></param>
        public void send(string s)
        {
            try
            {
                byte[] arrMsg = System.Text.Encoding.UTF8.GetBytes(s);
                byte[] arrSendMsg = new byte[arrMsg.Length + 1];
                arrSendMsg[0] = 0; // 用来表示发送的是消息数据 
                Buffer.BlockCopy(arrMsg, 0, arrSendMsg, 1, arrMsg.Length);
                sockClient.Send(arrSendMsg); // 发送消息； 
            }
            catch (Exception)
            {

                throw;
            }

        } 
        #endregion