网络编程之Socket的TCP协议实现客户端与客户端之间的通信

     我认为当你学完某个知识点后，最好是做一个实实在在的小案例。这样才能更好对知识的运用与掌握

如果你看了我前两篇关于socket通信原理的入门文章。我相信对于做出我这个小案列是完全没有问题的！！

既然是小案列。就难免会有很多不足，所以还请大家见谅。先说下用此案例实现的功能

利用Socke的TCP协议实现了

1：端与端之间的通信(客户端和客户端)包括发送文字，小文件，抖动效果

2：同步实现好友下线与上线的效果，即有其他客户端上线会通知其他已经在线的客户端

3：实现自定义通信协议

 

服务器窗体布局

 

 

 

 

 

布局很明了。顶部一个DataGridView显示连接的客户端信息，来一个就新增一个。走一个就干掉一个。

下面就是显示服务器信息

客户端布局：

窗口布局是不是很大众呢。QQ啊。飞秋。类似的布局。

好了。现在启动服务器。连接两个客户端试试

服务器已经获取了客户端信息

 

客服端用户列表是空的？因为这里我的处理是不能跟自己聊天所以列表是不显示自己的ip的

那么在登陆一个客户端呢？

服务器

此时客户端都已经获取了对方上线的ip

 

此时就可以通信了。那来试试上面说的功能。发送文字，抖动，和图片

 

发送文字：

 

 

箭头的方向是发送的开始，反过来发送也是可以的

 

当有人下线，客户端会更新 "用户列表"，同时服务器也会端口对下线者的通信

比如：当端口号为：6477下线。即端口连接

 

 

 

刚下线一个客户端。所以现在登陆一个客户端

发送文件： 这里仅仅是小文件。显示发送一个图片

当选择文件文件后。文件路径会显示在框中

从图中可以看出。是一个图片。名字是 2

单击发送。接收的用户会提示是否接受该文件。

 

当单击是的时候。则弹出保存对话框

 

从图片中可以看出来，这里获取到了文件名称。那么客户端是怎么获取到的呢？在下面的代码中会一一讲解

现在重新命名 new.jpg保存看看。已经成功了

 

抖动效果

为了让大家看到抖动效果。这里放一个gif图片。其实跟QQ抖动类似。当然没他那么优美。那么好看。

 

 

看看一个通信的流程图

 

 

图片中红色的标记框就是

首先：我第一次登陆成功，服务器发送在线好友给我，显示在用户列表中

同时通知其他在线用户。用人(我)上线了。

当然。当有人上线。服务器也会通知我。然后把上线的ip添加到用列表中

当我下线的时候。通知服务器我下线了。服务器则通知其他在线用户。更新列表

发送消息也是先发送到服务器。然后服务器在转发。

 

好了。具体功能就是这些了。带着这些实现的功能读下面的代码。思绪应该会比较清晰

 

还记得创建服务器的三个步骤吗？

第一：创建监听的socket

第二：绑定监听用个的ip和端口号

第三：开始监听

 

因为监听和获取消息都是要循环的。要么用多线程。要么用socket异步。所以这两个方法要独立出来

创建StartServer()方法。用来开启服务器

/// <summary>
        /// 打开服务器
        /// </summary>
        void StartServer()
        {
            try
            {
                string _ip = tbIp.Text;
                int _point = int.Parse(tbPoint.Text);

                //创建监听客户端请求的socket
                Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                //监听用的ip和端口
                IPAddress address = IPAddress.Parse(_ip);
                IPEndPoint point = new IPEndPoint(address, _point);

                //绑定
                socket.Bind(point);
                socket.Listen(10);


                //异步 开始监听
                socket.BeginAccept(new AsyncCallback(Listen), socket);


                //禁用当前按钮
                btnStart.Enabled = false;

                //启动时间
                startTime.Text = DateTime.Now.ToString();

                //底部提示消息
                tssMsg.Text = "服务器已经启动";
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }

        }

从代码可以看出来。我用到了异步通信 BeginAccept方法 回掉方法是Listen

Listen方法即上面说的要循环监听的代码

 

Listen方法

/// <summary>
        /// 开始监听
        /// </summary>
        /// <param name="result"></param>
        void Listen(IAsyncResult result)
        {

            try
            {
                //获取监听的socket
                Socket clientSocket = result.AsyncState as Socket;
                //与服务器通信的socket
                Socket connSocket = clientSocket.EndAccept(result);

                string ip = connSocket.RemoteEndPoint.ToString();
                //连接成功。保存信息
                if (!Common.connSocket.ContainsKey(ip))
                    Common.connSocket.Add(ip, connSocket);

                //连接成功，更新服务器信息
                changeList(connSocket);


                //等待新的客户端连接 ，相当于循环调用
                clientSocket.BeginAccept(new AsyncCallback(Listen), clientSocket);

                byte[] buffer = new byte[1024 * 1024];


                //接收来自客户端信息 ，相当于循环调用
                connSocket.BeginReceive(Common.ReceiveBuffer, 0, Common.ReceiveBuffer.Length, 0, new AsyncCallback(Receive), connSocket);

                //用户第一次登陆。获取所有在线用户  如果有好友功能。则获取他的好友
                SendesClient(connSocket);
            }
            catch (Exception ex)
            {

                //MessageBox.Show(ex.Message);
            }


        }

如果你在想为什么Listen方法要这样定义：

 void Listen(IAsyncResult result)

你可以去看下多线程，异步委托方面的知识

我博客也有这方面的入门：http://www.cnblogs.com/nsky/p/4425286.html

这里把连接的客服端保存在字典中

key：当前的ip value ：当前的socke通信

//连接成功。保存信息
if (!Common.connSocket.ContainsKey(ip))
        Common.connSocket.Add(ip, connSocket);

 

 

当客户端连接。就获取所有在线的ip

//用户第一次登陆。获取所有在线用户  如果有好友功能。则获取他的好友
  SendesClient(connSocket);

 

SendesClient方法

/// <summary>
        /// 把上线的人发送到客户端
        /// </summary>
        /// <param name="connSocket">当前连接的客户端</param>
        void SendesClient(Socket connSocket)
        {
            //自定义协议：[命令 2位]
            /*
             * 第一位：10代表是首次登陆获取所有好友，把自己的ip放最后一位
             * 好像这里默认已经是最后一位了？？
             */
            string key = connSocket.RemoteEndPoint.ToString();
            //把自己的ip删除
            if (Common.connSocket.ContainsKey(key))
                Common.connSocket.Remove(key);

            //把自己的key添加到最后一位
            if (!Common.connSocket.ContainsKey(key))
                Common.connSocket.Add(key, connSocket);

            //发送到客户端
            byte[] clientByte = Encoding.UTF8.GetBytes(string.Join(",", Common.connSocket.Keys));


            //List<byte> bbb = new List<byte>();
            //bbb.Add(1);
            //bbb.AddRange(clientByte);

            List<byte> li = clientByte.ToList();
            li.Insert(0, 10);//第一位插入10 代表是获取好友

            //把当前在线ip发送给自己
            connSocket.Send(li.ToArray());

            //告诉其他在线的用户。我上线啦，求勾搭
            //var online = from onn in Common.connSocket
            //             where !onn.Key.Contains(connSocket.RemoteEndPoint.ToString())  //筛选，不包含自己的ip
            //             select onn;

            //if (online.Count() <= 0) return; //当前没有上线的

            foreach (KeyValuePair<string, Socket> item in Common.connSocket)
            {
                //不需要给自己发送。因为当自己上线的时候。就已经获取了在线的ip
                if (item.Key == connSocket.RemoteEndPoint.ToString()) continue;
                //多线程通知在线用户。
                Thread thread = new Thread(() =>
                {
                    byte[] buffer = Encoding.UTF8.GetBytes(connSocket.RemoteEndPoint.ToString());
                    List<byte> list = buffer.ToList();
                    //有人上线
                    //[命令(12)| ip(上线的ip)| ...]
                    list.Insert(0, 12);//说明有人上线
                    item.Value.Send(list.ToArray());
                });
                thread.IsBackground = true;
                thread.Start();
            }

            //判断当前用户是否还处于连接状态
            //if (Common.connSocket.ContainsKey(connSocket.RemoteEndPoint.ToString()))
            //connSocket.Send(buffer);

            //有人下线。就通知所有在线的人数
            //如果是qq我想应该是通知我的好友。不是知道是不是

            /*
             * 如果在线有 A B C 
             * 那么A下线
             * 是不是要通知B C
             * 还是在B C 定时访问服务器来获取在线人数呢？
             * 待解决
             */
        }

 

 

那么Listen方法是怎么循环监听的呢？其实就是在Listen里面循环调用自己

 //等待新的客户端连接 ，相当于循环调用
  clientSocket.BeginAccept(new AsyncCallback(Listen), clientSocket);

 

 

监听有客服端连接成功。就开始接受客户端信息

 //接收来自客户端信息 ，相当于循环调用
  connSocket.BeginReceive(Common.ReceiveBuffer, 0, Common.ReceiveBuffer.Length, 0, new AsyncCallback(Receive), connSocket);

Common.ReceiveBuffer是什么？？

这是我把公共的数据封装在了一个Common类里面。下面会给出

 

循环监听有了。那么写一个循环接收消息的也就很简单了。依葫芦画瓢

Receive方法：

 /// <summary>
        /// 接收来自客户端信息
        /// </summary>
        /// <param name="result"></param>
        void Receive(IAsyncResult result)
        {

            //与客户端通信的socket
            Socket clientSocket = result.AsyncState as Socket;

            try
            {
                //获取实际的长度值
                int num = clientSocket.EndReceive(result);
                if (num > 0)
                {
                    byte[] data = new byte[num];
                    //复制实际的长度到data字节数组中
                    Array.Copy(Common.ReceiveBuffer, 0, data, 0, num);

                    //判断协议位
                    int command = data[0];

                    //获取内容
                    string source = Encoding.UTF8.GetString(data, 1, num - 1);

                    //获取接收者的ip
                    string receiveIp = source.Split(',')[0];


                    if (command == 1) //说明发送的是文字
                    {
                        /*协议：
                         * //[命令(1)|对方的ip和自己的ip 50位)| 内容(文字) | ...]
                         */
                        //获取接收者通信连接的socket
                        if (Common.connSocket.ContainsKey(receiveIp))
                        {
                            Common.connSocket[receiveIp].Send(data);
                        }
                    }
                    else if (command == 0) //说明是发送的文件
                    {
                        /*协议: 这里50位不知道是否理想。
                         * [命令(0)| ip(对方的ip和自己的ip 50位)| 内容(文件大小和文件全名 30位)|响应(文件内容) | ...]
                         */

                        //获取接收者通信连接的socket
                        if (Common.connSocket.ContainsKey(receiveIp))
                        {
                            Common.connSocket[receiveIp].Send(data);
                        }
                    }
                    else if (command == 2)//抖动一下
                    {
                        //协议
                        //震动
                        //[命令(2)| 对方的ip和自己的ip 50位| ...]

                        //获取接收者通信连接的socket
                        if (Common.connSocket.ContainsKey(receiveIp))
                        {
                            Common.connSocket[receiveIp].Send(data);
                        }
                    }

                    //string msg = Encoding.UTF8.GetString(data);
                    //MessageBox.Show(msg);


                    //接收其他信息
                    clientSocket.BeginReceive(Common.ReceiveBuffer, 0, Common.ReceiveBuffer.Length, 0, new AsyncCallback(Receive), clientSocket);

                }
                else //客户端断开
                {
                    clientOff(clientSocket);
                }
            }
            catch (Exception ex)
            {
                clientOff(clientSocket);
            }

        }

 

当客户端端口会执行clientOff方法。用来通知其他用户。更新列表

clientOff方法

 /// <summary>
        /// 客户端关闭
        /// </summary>
        void clientOff(Socket clientSocket)
        {
            //从集合删除下线的ip
            string outIp = clientSocket.RemoteEndPoint.ToString();
            if (Common.connSocket.ContainsKey(outIp))
                Common.connSocket.Remove(outIp);

            //更新服务器在线人数
            changOnlineCount(false);

            this.Invoke(new Action(() =>
            {
                //更新列表
                //删除退出的ip
                for (int i = 0; i < dgvList.Rows.Count; i++)
                {
                    if (dgvList.Rows[i].Tag.ToString() == outIp)
                    {
                        dgvList.Rows.RemoveAt(i);
                        break;
                    }
                }
            }));

            clientSocket.Shutdown(SocketShutdown.Receive);
            clientSocket.Close();

            //通知所有在线用户。有人下线了。需要更新列表，如果是qq是通知我的好友。不知道是不是这样
            /*这里有点疑问：
             * 是客户端定时到服务器获取在线用户？
             * 还是服务器通知客户端
             
             */

            //有人下线 协议
            //[命令(11)| ip(下线的ip)| ...]

            //我这里通知客户端吧
            foreach (KeyValuePair<string, Socket> item in Common.connSocket)
            {
                Thread thread = new Thread(() =>
                {
                    byte[] buffer = Encoding.UTF8.GetBytes(outIp);
                    List<byte> list = buffer.ToList();
                    list.Insert(0, 11);//添加协议位
                    item.Value.Send(list.ToArray());
                });
                thread.IsBackground = true;
                thread.Start();


                //多线程。通知每个在线用户。更新列表
                //ThreadPool.QueueUserWorkItem(new WaitCallback(new Action<object>((o) =>
                //{
                //    string result = string.Join(",", Common.connSocket.Keys);
                //    byte[] buffer = Encoding.UTF8.GetBytes(result);
                //    try
                //    {
                //        //客户端关闭，则发送报异常
                //        item.Value.Send(buffer);
                //    }
                //    catch (Exception ex)
                //    {

                //    }
                //})));
                //string result = string.Join(",", Common.connSocket.Keys);
                //byte[] buffer = Encoding.UTF8.GetBytes(result);
                //item.Value.Send(buffer);

            }
        }

 

有没有想过。服务器是怎么知道客户端发送的是文字。文件还是抖动呢？

这里就要提到自定义协议了。双方约定好。比如：

客户端发送0 就代表是文字。 发送1 则代表是文件 2 则代表是抖动。

 

我这里自定义的协议如下。不能说很好。只能说马马虎虎过得去

/*********************协议说明***********************/
        //根据协议解码
        /*
         * 自定义协议规则
         *  [ 命令(1) | 内容(30) | ip(22)| 响应(....) | ...]
           命令：0-文件 1-文字 2-震动
         * 内容：
         * 文件（长度，文件名字+后缀名） 响应(文件的字节)
         * 文字(内容)
         * 震动()
         * ip(自己的ip和对方的ip)
         * 
         * [ 命令(1) | ip(22) | 内容(30)| 响应(....) | ...]
         * 
         * 文件：
         *  [命令(0)| ip(自己的ip和对方的ip)| 内容(文件大小和文件全名)|响应(文件内容) | ...]
         * 文字：
         *  [命令(1)|对方的ip和自己的ip 50位)| 内容(文字) | ...]
         * 震动
         *  [命令(2)| ip(对方的ip)| ...]
         * 更新在线人数
         * [命令(3)| ip(自己的ip和对方的ip)| ...]
         * 第一次登陆获取在线(好友)人数
         * [命令(10)| ip(自己的ip和所有的ip)| ...]
         * 有人下线
         *  [命令(11)| ip(下线的ip)| ...]
         * 有人上线
         *  [命令(12)| ip(上线的ip)| ...]
         *  0
         *  1
         *  2
         *  3
         *  4
         *  5
         * 
         */

 

既然协议有了。那么就可以根据协议发送数据包。服务器和其他客户端就可以根据协议解包。

这里来说下发送文件的协议

从上面可以看到我定义的文件协议：

[命令(0)| ip(自己的ip和对方的ip)| 内容(文件大小和文件全名)|响应(文件内容) | ...]

 

先贴上发送文件的代码(客户端发送)。然后根据我的思路来分析

客户端发送文件代码

/// <summary>
        /// 发送文件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void btnSendFile_Click(object sender, EventArgs e)
        {
            //判断是否有选择用户
            string sendUser = cbList.Text;

            if (string.IsNullOrEmpty(sendUser))
            {
                //提示
                tbHis.AppendText("请选择要发送的用户...\n");
                return;
            }
            //判断是否选择了文件
            else if (string.IsNullOrEmpty(tbFile.Text))
            {
                tbHis.AppendText("请选择文件\n");
                tbHis.AppendText("\n");
                return;
            }
            //开始读取文件
            using (FileStream fs = new FileStream(tbFile.Text, FileMode.Open, FileAccess.Read))
            {
                //大文件会内存溢出
                //引发类型为“System.OutOfMemoryException”的异常。
                //所以大文件只能 续传。像QQ一样在线接收的方式。
                byte[] buffer = new byte[fs.Length];
                //获取实际的字节数，如果有需要的话。
                int num = fs.Read(buffer, 0, buffer.Length);

                /*协议: 这里50位不知道是否理想？？
                 * 是不是可以修改为：第一位 协议 第二位标记ip的长度 第三位标记内容的长度？？
                 * [命令(0)| ip(对方的ip和自己的ip 50位)| 内容(文件大小和文件全名 30)|响应(文件内容) | ...]
                 */
                string allIp = string.Format("{0},{1}", cbList.Text, myIp.Text);
                byte[] sendIp = Encoding.UTF8.GetBytes(allIp);

                List<byte> list = sendIp.ToList();

                //sendIp 不够50位
                if (sendIp.Length < 50)
                {
                    for (int i = 0; i < 50 - sendIp.Length; i++)
                    {
                        list.Add(0);
                    }
                }
                list.Insert(0, 0); //添加协议位
                //添加内容
                byte[] fileByte = Encoding.UTF8.GetBytes(Common.SafeFileName);
                list.AddRange(fileByte);
                //内容是否够30
                if (fileByte.Length < 30)
                {
                    for (int i = 0; i < 30 - fileByte.Length; i++)
                    {
                        list.Add(0);
                    }
                }
                //添加响应
                list.AddRange(buffer);

                //开始发送
                Common.connSocket.Send(list.ToArray());
            }
        }

 

字节数组必须根据你定义的协议来拼接。这样在服务端才好解包

我这里把ip放到了List<byte>中

List<byte> list = sendIp.ToList();

然后在list前面插入协议位：0 ，因为我定义的协议是0代表发送文件

list.Insert(0, 0); //添加协议位

 

是否还记得上面提到的。客户端接收文件。打开保存对话框。自动补全了文件名。是怎么做的吗？

因为协议中发文件名发过去了

//添加内容
byte[] fileByte = Encoding.UTF8.GetBytes(Common.SafeFileName);
list.AddRange(fileByte);

还有因为不知道ip的固定长度。所以我这里限制是50位。不够的话就补加空，不知道这样是否划算

//sendIp 不够50位
  if (sendIp.Length < 50)
   {
     for (int i = 0; i < 50 - sendIp.Length; i++)
       {
            list.Add(0);
       }
  }

所以的数据根据协议打包后。就可以发送到服务器。在服务器解包。获取目的者的ip。开始转发

Receive方法中你可以找到解包的代码，部分如下：

                    byte[] data = new byte[num];
                    //复制实际的长度到data字节数组中
                    Array.Copy(Common.ReceiveBuffer, 0, data, 0, num);

                    //判断协议位
                    int command = data[0];

                    //获取内容
                    string source = Encoding.UTF8.GetString(data, 1, num - 1);

                    //获取接收者的ip
                    string receiveIp = source.Split(',')[0];


                    if (command == 1) //说明发送的是文字
                    {
                        /*协议：
                         * //[命令(1)|对方的ip和自己的ip 50位)| 内容(文字) | ...]
                         */
                        //获取接收者通信连接的socket
                        if (Common.connSocket.ContainsKey(receiveIp))
                        {
                            Common.connSocket[receiveIp].Send(data);
                        }
                    }

 

获取协议位：

int command = data[0];

注：

你会发现我这里在服务器解包判断协议毫无意义。因为第一位是命令。而后面接着是ip。这些长度都是固定的。

只有取出来ip发送到指定的客户端。让客户端解包判断协议就是了。没错。因为我这里本来加个功能。如果是文件则把文件缓存起来。所以就判断

了协议的命令。你可以根据自己的需求去做。

 

发送到了客户端，就理所当然的要判断协议位了。如果是抖动就抖一下。是文件。就提示是否接受。等等

看看客户端解包代码：

记住：下面的Receive方法是客户端中的方法。用力接收服务器发来的消息

/// <summary>
        /// 接收来自服务器的消息
        /// </summary>
        /// <param name="result"></param>
        void Receive(IAsyncResult result)
        {
            Socket clientSocket = result.AsyncState as Socket;

            //byte[] b = new byte[1024 * 1024];
            try
            {
                //获取实际的长度
                int num = clientSocket.EndReceive(result);
                if (num > 0)
                {
                    //MessageBox.Show(num.ToString());
                    byte[] buffer = new byte[num];
                    Array.Copy(Common.buffer, 0, buffer, 0, num); //复制数据到data
                    //string ip = Encoding.UTF8.GetString(data);


                    //以下是客户端=》服务器==》服务器
                    /*
                     * 当if else 超过3个
                     * 
                     * 建议用switch case语句
                     */

                    //获取口令
                    int command = buffer[0];
                    //说明是获取好友
                    if (command == 10)
                    {
                        //协议说明
                        //第一次登陆获取在线(好友)人数
                        //[命令(10)| ip(自己的ip和所有好友的ip)| ...]


                        //其实用户本地ip也可以这样获取
                        //string cy = clientSocket.LocalEndPoint;

                        string allIp = Encoding.UTF8.GetString(buffer, 1, num - 1);
                        string[] temp = allIp.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);


                        //跨线程操作UI
                        this.Invoke(new Action(() =>
                        {
                            myIp.Text = temp.Length > 0 ? temp[temp.Length - 1] : "";

                            //排除自己的ip
                            var other = from i in temp where !i.Contains(myIp.Text) select i;

                            cbList.Items.Clear();//清空
                            cbList.Items.AddRange(other.ToArray()); //绑定列表

                            if (cbList.Items.Count > 0)
                                cbList.SelectedIndex = 0;//默认选中第一个
                        }));

                    }
                    else if (command == 11) //说明是有人下线
                    {
                        //协议说明
                        // 有人下线
                        //[命令(11)| ip(下线的ip)| ...]

                        //获取下线的ip
                        string outIp = Encoding.UTF8.GetString(buffer, 1, num - 1);

                        this.Invoke(new Action(() =>
                        {
                            //删除下线的ip
                            cbList.Items.Remove(outIp);
                            if (cbList.Items.Count > 0)
                                cbList.SelectedIndex = 0;//默认选中第一个
                        }));
                    }
                    else if (command == 12) //有人上线了
                    {
                        //协议说明
                        // 有人上线
                        //[命令(12)| ip(上线的ip)| ...]

                        //获取上线的ip
                        string onlineIp = Encoding.UTF8.GetString(buffer, 1, num - 1);
                        //添加上线的ip

                        this.Invoke(new Action(() =>
                        {
                            //添加上线的ip
                            cbList.Items.Add(onlineIp);
                            if (cbList.Items.Count > 0)
                                cbList.SelectedIndex = 0;//默认选中第一个
                        }));
                    }

                    //以下是客户端=》服务器==》客户端

                    else if (command == 1)
                    {
                        //协议：
                        //[命令(1)|对方的ip和自己的ip 50位)| 内容(文字) | ...]

                        //获取ip段
                        string[] sourceIp = Encoding.UTF8.GetString(buffer, 1, 50).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

                        //发消息来的ip
                        string fromIp = sourceIp[1];



                        //获取内容
                        string content = Encoding.UTF8.GetString(buffer, 50 + 1, num - 50 - 1);

                        this.Invoke(new Action(() =>
                        {
                            //列表框中选择当前的ip
                            cbList.Text = fromIp.ToString();

                            //显示内容
                            tbHis.AppendText(string.Format("时间：{0}\n", DateTime.Now.ToString()));
                            //tbHis.AppendText(string.Format("提示{0}对我说：", fromIp)); //我操。这样怎么就不行
                            tbHis.AppendText(fromIp + "\n");
                            tbHis.AppendText("对你说：\n");
                            tbHis.AppendText(content + "\n");
                            tbHis.AppendText("\n");
                        }));
                    }
                    else if (command == 0) //发送的文件
                    {
                        /*协议: 这里50位不知道是否理想。
                         * [命令(0)| ip(对方的ip和自己的ip 50位)| 内容(文件大小和文件全名 30位)|响应(文件内容) | ...]
                         */

                        //这里有冗余代码

                        //获取ip段
                        string[] sourceIp = Encoding.UTF8.GetString(buffer, 1, 50).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

                        //发消息来的ip
                        string fromIp = sourceIp[1];

                        this.Invoke(new Action(() =>
                        {
                            //列表框中选择当前的ip
                            cbList.Text = fromIp.ToString();
                        }));


                        //获取内容
                        string content = Encoding.UTF8.GetString(buffer, 50 + 1, 30);

                        //获取响应
                        //string pass = Encoding.UTF8.GetString(buffer, 50 + 30 + 1, num - 50 - 30 - 1);

                        //显示
                        //tbHis.AppendText(string.Format("{0}给你发了一个文件：{1}\n", fromIp, content));
                        tbHis.AppendText(fromIp);
                        tbHis.AppendText("给你发了一个文件");
                        tbHis.AppendText(content + "\n");
                        tbHis.AppendText("\n");


                        //提示用户是否接收文件
                        if (MessageBox.Show("是否接受文件\n" + content, "接收文件", MessageBoxButtons.YesNo) == DialogResult.Yes)
                        {
                            //开始保存
                            SaveFileDialog sfd = new SaveFileDialog();
                            sfd.FileName = content;

                            //获取文件类型
                            string ex = content.Split('.')[1];

                            //保存文件类型
                            sfd.Filter = "|*." + ex;
                            if (sfd.ShowDialog(this) == DialogResult.OK)
                            {
                                using (FileStream fs = new FileStream(sfd.FileName, FileMode.Create))
                                {
                                    fs.Write(buffer, 50 + 30 + 1, num - 50 - 30 - 1);
                                }
                            }

                        }

                    }
                    else if (command == 2) //发送抖动
                    {
                        //如果窗口在任务栏。则显示
                        this.Show();
                        this.WindowState = FormWindowState.Normal;
                        this.Activate();

                        int n = -1;

                        for (int i = 0; i < 10; i++)
                        {
                            n = -n;
                            this.Location = new Point(this.Location.X + 10 * n, this.Location.Y + 10 * n);
                            this.TopMost = true;//在所有窗口的顶部
                            System.Threading.Thread.Sleep(50);
                        }

                        //抖动完成。结束顶层显示
                        this.TopMost = false;
                    }

                    //连接成功，再一次获取服务器发来的消息
                    clientSocket.BeginReceive(Common.buffer, 0, Common.buffer.Length, 0, new AsyncCallback(Receive), clientSocket);

                }
            }
            catch (Exception ex) //服务器端口
            {
                MessageBox.Show(ex.Message);
                clientSocket.Shutdown(SocketShutdown.Receive);
                clientSocket.Close();
            }
        }

 

 

都是if else if判断的。着实看着会晕乎乎的。因为是小案列。就没去过多的封装。大家可以根据自己的喜好去封装

上面大部分都是讲的服务端口的代码。相比客户端就是一样的。只是少了一个监听的代码。直接连接服务器。接收和发送消息就ok了

这里就不分析了。稍后直接贴上参考代码

当然socket通信协议方面的知识不单单就我这点皮毛。大家自己可以深入研究。

比如：很多网站右下角都会有这样一个窗口，大家都见过吧。

 

我想这也是相同的原理。当打开浏览器。ajax异步去连接服务器，

获取消息发送到客户端。你说呢？

 

因为想做个打飞机的游戏。其实网上也有很多源码，可我认为别人的终究是别人的。只有自己做过那才叫曾经拥有。

可单机版的太没有挑战性，那就实现一个多人在线一起玩的。就涉及到了服务器

所以想用C#写一个服务器，unity3d做客户端，与之通信。所以才有了这篇博文的诞生。

 

最后把全部源码给大家参考下

服务端源码：

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.Net;
using System.Net.Sockets;
using System.Threading;

namespace TopServer
{
    public partial class mainServer : Form
    {

        /*********************协议说明***********************/
        //根据协议解码
        /*
         * 自定义协议规则
         *  [ 命令(1) | 内容(30) | ip(22)| 响应(....) | ...]
           命令：0-文件 1-文字 2-震动
         * 内容：
         * 文件（长度，文件名字+后缀名） 响应(文件的字节)
         * 文字(内容)
         * 震动()
         * ip(自己的ip和对方的ip)
         * 
         * [ 命令(1) | ip(22) | 内容(30)| 响应(....) | ...]
         * 
         * 文件：
         *  [命令(0)| ip(自己的ip和对方的ip)| 内容(文件大小和文件全名)|响应(文件内容) | ...]
         * 文字：
         *  [命令(1)|对方的ip和自己的ip 50位)| 内容(文字) | ...]
         * 震动
         *  [命令(2)| ip(对方的ip)| ...]
         * 更新在线人数
         * [命令(3)| ip(自己的ip和对方的ip)| ...]
         * 第一次登陆获取在线(好友)人数
         * [命令(10)| ip(自己的ip和所有的ip)| ...]
         * 有人下线
         *  [命令(11)| ip(下线的ip)| ...]
         * 有人上线
         *  [命令(12)| ip(上线的ip)| ...]
         *  0
         *  1
         *  2
         *  3
         *  4
         *  5
         * 
         */

        public mainServer()
        {
            InitializeComponent();
            Init();
        }

        /// <summary>
        /// 初始化datagridview属性
        /// </summary>
        public void Init()
        {

            #region datagridview一些属性设置
            dgvList.AllowUserToAddRows = false;
            dgvList.AllowUserToDeleteRows = false;
            dgvList.AllowUserToResizeColumns = false;
            dgvList.AllowUserToResizeRows = false;
            dgvList.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
            dgvList.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize;
            dgvList.MultiSelect = false;
            dgvList.ReadOnly = true;
            dgvList.RowHeadersVisible = false;
            dgvList.BackgroundColor = Color.White;
            dgvList.ScrollBars = ScrollBars.Vertical;
            dgvList.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
            #endregion

            //窗体加载事件
            //this.Load += new EventHandler(mainServer_Load);

            //启动服务器按钮
            this.btnStart.Click += new EventHandler(btnStart_Click);

            //关闭服务器按钮
            this.btnStop.Click += new EventHandler(btnStop_Click);
        }

        /// <summary>
        /// 关闭服务器
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void btnStop_Click(object sender, EventArgs e)
        {
            if (Common.ListenSocket != null)
            {
                Common.ListenSocket.Close();
                Common.ListenSocket = null;
                btnStart.Enabled = true;
                //底部提示消息
                tssMsg.Text = "服务器已经关闭";
            }
        }

        /// <summary>
        /// 启动服务器
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void btnStart_Click(object sender, EventArgs e)
        {
            StartServer();
        }

        /// <summary>
        /// 窗体加载事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void mainServer_Load(object sender, EventArgs e)
        {
            //启动时间
            startTime.Text = DateTime.Now.ToString();

            //启动服务器
            StartServer();
        }

        /// <summary>
        /// 打开服务器
        /// </summary>
        void StartServer()
        {
            try
            {
                string _ip = tbIp.Text;
                int _point = int.Parse(tbPoint.Text);

                //创建监听客户端请求的socket
                Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                //监听用的ip和端口
                IPAddress address = IPAddress.Parse(_ip);
                IPEndPoint point = new IPEndPoint(address, _point);

                //绑定
                socket.Bind(point);
                socket.Listen(10);


                //异步 开始监听
                socket.BeginAccept(new AsyncCallback(Listen), socket);


                //禁用当前按钮
                btnStart.Enabled = false;

                //启动时间
                startTime.Text = DateTime.Now.ToString();

                //底部提示消息
                tssMsg.Text = "服务器已经启动";
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }

        }

        /// <summary>
        /// 开始监听
        /// </summary>
        /// <param name="result"></param>
        void Listen(IAsyncResult result)
        {

            try
            {
                //获取监听的socket
                Socket clientSocket = result.AsyncState as Socket;
                //与服务器通信的socket
                Socket connSocket = clientSocket.EndAccept(result);

                string ip = connSocket.RemoteEndPoint.ToString();
                //连接成功。保存信息
                if (!Common.connSocket.ContainsKey(ip))
                    Common.connSocket.Add(ip, connSocket);

                //连接成功，更新服务器信息
                changeList(connSocket);


                //等待新的客户端连接 ，相当于循环调用
                clientSocket.BeginAccept(new AsyncCallback(Listen), clientSocket);

                byte[] buffer = new byte[1024 * 1024];


                //接收来自客户端信息 ，相当于循环调用
                connSocket.BeginReceive(Common.ReceiveBuffer, 0, Common.ReceiveBuffer.Length, 0, new AsyncCallback(Receive), connSocket);

                //用户第一次登陆。获取所有在线用户  如果有好友功能。则获取他的好友
                SendesClient(connSocket);
            }
            catch (Exception ex)
            {

                //MessageBox.Show(ex.Message);
            }


        }
        /// <summary>
        /// 接收来自客户端信息
        /// </summary>
        /// <param name="result"></param>
        void Receive(IAsyncResult result)
        {

            //与客户端通信的socket
            Socket clientSocket = result.AsyncState as Socket;

            try
            {
                //获取实际的长度值
                int num = clientSocket.EndReceive(result);
                if (num > 0)
                {
                    byte[] data = new byte[num];
                    //复制实际的长度到data字节数组中
                    Array.Copy(Common.ReceiveBuffer, 0, data, 0, num);

                    //判断协议位
                    int command = data[0];

                    //获取内容
                    string source = Encoding.UTF8.GetString(data, 1, num - 1);

                    //获取接收者的ip
                    string receiveIp = source.Split(',')[0];


                    if (command == 1) //说明发送的是文字
                    {
                        /*协议：
                         * //[命令(1)|对方的ip和自己的ip 50位)| 内容(文字) | ...]
                         */
                        //获取接收者通信连接的socket
                        if (Common.connSocket.ContainsKey(receiveIp))
                        {
                            Common.connSocket[receiveIp].Send(data);
                        }
                    }
                    else if (command == 0) //说明是发送的文件
                    {
                        /*协议: 这里50位不知道是否理想。
                         * [命令(0)| ip(对方的ip和自己的ip 50位)| 内容(文件大小和文件全名 30位)|响应(文件内容) | ...]
                         */

                        //获取接收者通信连接的socket
                        if (Common.connSocket.ContainsKey(receiveIp))
                        {
                            Common.connSocket[receiveIp].Send(data);
                        }
                    }
                    else if (command == 2)//抖动一下
                    {
                        //协议
                        //震动
                        //[命令(2)| 对方的ip和自己的ip 50位| ...]

                        //获取接收者通信连接的socket
                        if (Common.connSocket.ContainsKey(receiveIp))
                        {
                            Common.connSocket[receiveIp].Send(data);
                        }
                    }

                    //string msg = Encoding.UTF8.GetString(data);
                    //MessageBox.Show(msg);


                    //接收其他信息
                    clientSocket.BeginReceive(Common.ReceiveBuffer, 0, Common.ReceiveBuffer.Length, 0, new AsyncCallback(Receive), clientSocket);

                }
                else //客户端断开
                {
                    clientOff(clientSocket);
                }
            }
            catch (Exception ex)
            {
                clientOff(clientSocket);
            }

        }

        /// <summary>
        /// 客户端关闭
        /// </summary>
        void clientOff(Socket clientSocket)
        {
            //从集合删除下线的ip
            string outIp = clientSocket.RemoteEndPoint.ToString();
            if (Common.connSocket.ContainsKey(outIp))
                Common.connSocket.Remove(outIp);

            //更新服务器在线人数
            changOnlineCount(false);

            this.Invoke(new Action(() =>
            {
                //更新列表
                //删除退出的ip
                for (int i = 0; i < dgvList.Rows.Count; i++)
                {
                    if (dgvList.Rows[i].Tag.ToString() == outIp)
                    {
                        dgvList.Rows.RemoveAt(i);
                        break;
                    }
                }
            }));

            clientSocket.Shutdown(SocketShutdown.Receive);
            clientSocket.Close();

            //通知所有在线用户。有人下线了。需要更新列表，如果是qq是通知我的好友。不知道是不是这样
            /*这里有点疑问：
             * 是客户端定时到服务器获取在线用户？
             * 还是服务器通知客户端
             
             */

            //有人下线 协议
            //[命令(11)| ip(下线的ip)| ...]

            //我这里通知客户端吧
            foreach (KeyValuePair<string, Socket> item in Common.connSocket)
            {
                Thread thread = new Thread(() =>
                {
                    byte[] buffer = Encoding.UTF8.GetBytes(outIp);
                    List<byte> list = buffer.ToList();
                    list.Insert(0, 11);//添加协议位
                    item.Value.Send(list.ToArray());
                });
                thread.IsBackground = true;
                thread.Start();


                //多线程。通知每个在线用户。更新列表
                //ThreadPool.QueueUserWorkItem(new WaitCallback(new Action<object>((o) =>
                //{
                //    string result = string.Join(",", Common.connSocket.Keys);
                //    byte[] buffer = Encoding.UTF8.GetBytes(result);
                //    try
                //    {
                //        //客户端关闭，则发送报异常
                //        item.Value.Send(buffer);
                //    }
                //    catch (Exception ex)
                //    {

                //    }
                //})));
                //string result = string.Join(",", Common.connSocket.Keys);
                //byte[] buffer = Encoding.UTF8.GetBytes(result);
                //item.Value.Send(buffer);

            }
        }
        /// <summary>
        /// 把上线的人发送到客户端
        /// </summary>
        /// <param name="connSocket">当前连接的客户端</param>
        void SendesClient(Socket connSocket)
        {
            //自定义协议：[命令 2位]
            /*
             * 第一位：10代表是首次登陆获取所有好友，把自己的ip放最后一位
             * 好像这里默认已经是最后一位了？？
             */
            string key = connSocket.RemoteEndPoint.ToString();
            //把自己的ip删除
            if (Common.connSocket.ContainsKey(key))
                Common.connSocket.Remove(key);

            //把自己的key添加到最后一位
            if (!Common.connSocket.ContainsKey(key))
                Common.connSocket.Add(key, connSocket);

            //发送到客户端
            byte[] clientByte = Encoding.UTF8.GetBytes(string.Join(",", Common.connSocket.Keys));


            //List<byte> bbb = new List<byte>();
            //bbb.Add(1);
            //bbb.AddRange(clientByte);

            List<byte> li = clientByte.ToList();
            li.Insert(0, 10);//第一位插入10 代表是获取好友

            //把当前在线ip发送给自己
            connSocket.Send(li.ToArray());

            //告诉其他在线的用户。我上线啦，求勾搭
            //var online = from onn in Common.connSocket
            //             where !onn.Key.Contains(connSocket.RemoteEndPoint.ToString())  //筛选，不包含自己的ip
            //             select onn;

            //if (online.Count() <= 0) return; //当前没有上线的

            foreach (KeyValuePair<string, Socket> item in Common.connSocket)
            {
                //不需要给自己发送。因为当自己上线的时候。就已经获取了在线的ip
                if (item.Key == connSocket.RemoteEndPoint.ToString()) continue;
                //多线程通知在线用户。
                Thread thread = new Thread(() =>
                {
                    byte[] buffer = Encoding.UTF8.GetBytes(connSocket.RemoteEndPoint.ToString());
                    List<byte> list = buffer.ToList();
                    //有人上线
                    //[命令(12)| ip(上线的ip)| ...]
                    list.Insert(0, 12);//说明有人上线
                    item.Value.Send(list.ToArray());
                });
                thread.IsBackground = true;
                thread.Start();
            }

            //判断当前用户是否还处于连接状态
            //if (Common.connSocket.ContainsKey(connSocket.RemoteEndPoint.ToString()))
            //connSocket.Send(buffer);

            //有人下线。就通知所有在线的人数
            //如果是qq我想应该是通知我的好友。不是知道是不是

            /*
             * 如果在线有 A B C 
             * 那么A下线
             * 是不是要通知B C
             * 还是在B C 定时访问服务器来获取在线人数呢？
             * 待解决
             */
        }

        /// <summary>
        /// 更新列表
        /// </summary>
        /// <param name="socket"></param>
        void changeList(Socket socket)
        {
            //获取客户端信息 ip和端口号
            string ip = socket.RemoteEndPoint.ToString();
            //客户端登陆时间
            string time = DateTime.Now.ToString();

            //跨线程操作ui
            this.Invoke(new Action(() =>
            {
                //新增一行
                dgvList.Rows.Add();

                //获取当前dgvList的行
                int rows = dgvList.Rows.Count;

                //赋值
                dgvList.Rows[rows - 1].Cells[0].Value = ip;
                dgvList.Rows[rows - 1].Cells[1].Value = time;

                //把ip当作当前行的tag标记一下，为了删除行的时候可以找到该行
                dgvList.Rows[rows - 1].Tag = ip;

                //更新在线人数
                //lbCount.Text = int.Parse(lbCount.Text) + 1 + "";//后面加空字符串。转为字符串
                //或者
                //lbCount.Text = (int.Parse(lbCount.Text) + 1).ToString();

                //foreach (DataGridViewRow item in dgvList.Rows)
                //{
                //   if(item.Tag==ip)item.

                //}


                //dgvList.DataSource = Common.connSocket;

                //更新在线人数
                changOnlineCount(true);
            }));

        }

        /// <summary>
        /// 更新在线人数
        /// </summary>
        /// <param name="tag">true=>+ false=>-</param>
        void changOnlineCount(bool tag)
        {
            int num = 0;
            if (tag) num = int.Parse(lbCount.Text) + 1;
            else num = int.Parse(lbCount.Text) - 1;

            this.Invoke(new Action(() =>
            {
                //更新在线人数
                lbCount.Text = num.ToString();
                if (num == 0) Common.connSocket.Clear();

            }));
        }
    }

    /// <summary>
    /// 公共类
    /// </summary>
    public class Common
    {
        /// <summary>
        /// 保存服务器来的消息
        /// </summary>
        public static byte[] ReceiveBuffer = new byte[1024 * 1024];

        /// <summary>
        /// 监听用的socket
        /// </summary>
        public static Socket ListenSocket;

        /// <summary>
        /// 保存所有负责通信用是socket
        /// </summary>
        public static Dictionary<string, Socket> connSocket = new Dictionary<string, Socket>();
    }
}

 

 

客户端源码：

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.Net.Sockets;
using System.Net;
using System.Threading;
using System.IO;

namespace TopClient
{
    public partial class UserList : Form
    {
        public UserList()
        {
            InitializeComponent();
            Init();
        }
        public void Init()
        {
            //窗体加载
            this.Load += new EventHandler(UserList_Load);

            //发送文字
            this.btnSender.Click += new EventHandler(btnSender_Click);

            //选择文件
            this.btnChangeFile.Click += new EventHandler(btnChangeFile_Click);

            //发送文件
            this.btnSendFile.Click += new EventHandler(btnSendFile_Click);

            //抖动对方
            this.btnDd.Click += new EventHandler(btnDd_Click);

            //创建time 
            /*
             * 用力监听服务器是否开启
             */
            //Common.time = new System.Windows.Forms.Timer();
            //Common.time.Interval = 1000; //如果服务器未开启。则一秒访问一次
            //Common.time.Tick += new EventHandler(time_Tick);
        }
        /// <summary>
        /// 发送抖动
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void btnDd_Click(object sender, EventArgs e)
        {
            //判断是否有选择用户
            string sendUser = cbList.Text;

            if (string.IsNullOrEmpty(sendUser))
            {
                //提示
                tbHis.AppendText("请选择要抖动的用户...\n");
                return;
            }
            //协议
            //震动
            //[命令(2)| 对方的ip和自己的ip 50位| ...]
            string allIp = string.Format("{0},{1}", cbList.Text, myIp.Text);

            byte[] sendIp = Encoding.UTF8.GetBytes(allIp);

            List<byte> list = sendIp.ToList();
            list.Insert(0, 2);//添加协议位

            //sendIp 不够50位
            if (sendIp.Length < 50)
            {
                for (int i = 0; i < 50 - sendIp.Length; i++)
                {
                    list.Add(0);
                }
            }
            //开始发送
            Common.connSocket.Send(list.ToArray());
        }

        /// <summary>
        /// 发送文件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void btnSendFile_Click(object sender, EventArgs e)
        {
            //判断是否有选择用户
            string sendUser = cbList.Text;

            if (string.IsNullOrEmpty(sendUser))
            {
                //提示
                tbHis.AppendText("请选择要发送的用户...\n");
                return;
            }
            //判断是否选择了文件
            else if (string.IsNullOrEmpty(tbFile.Text))
            {
                tbHis.AppendText("请选择文件\n");
                tbHis.AppendText("\n");
                return;
            }
            //开始读取文件
            using (FileStream fs = new FileStream(tbFile.Text, FileMode.Open, FileAccess.Read))
            {
                //大文件会内存溢出
                //引发类型为“System.OutOfMemoryException”的异常。
                //所以大文件只能 续传。像QQ一样在线接收的方式。
                byte[] buffer = new byte[fs.Length];
                //获取实际的字节数，如果有需要的话。
                int num = fs.Read(buffer, 0, buffer.Length);

                /*协议: 这里50位不知道是否理想？？
                 * 是不是可以修改为：第一位 协议 第二位标记ip的长度 第三位标记内容的长度？？
                 * [命令(0)| ip(对方的ip和自己的ip 50位)| 内容(文件大小和文件全名 30)|响应(文件内容) | ...]
                 */
                string allIp = string.Format("{0},{1}", cbList.Text, myIp.Text);
                byte[] sendIp = Encoding.UTF8.GetBytes(allIp);

                List<byte> list = sendIp.ToList();

                //sendIp 不够50位
                if (sendIp.Length < 50)
                {
                    for (int i = 0; i < 50 - sendIp.Length; i++)
                    {
                        list.Add(0);
                    }
                }
                list.Insert(0, 0); //添加协议位
                //添加内容
                byte[] fileByte = Encoding.UTF8.GetBytes(Common.SafeFileName);
                list.AddRange(fileByte);
                //内容是否够30
                if (fileByte.Length < 30)
                {
                    for (int i = 0; i < 30 - fileByte.Length; i++)
                    {
                        list.Add(0);
                    }
                }
                //添加响应
                list.AddRange(buffer);

                //开始发送
                Common.connSocket.Send(list.ToArray());
            }
        }

        /// <summary>
        /// 选择文件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void btnChangeFile_Click(object sender, EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            if (ofd.ShowDialog() == DialogResult.OK)
            {
                tbFile.Text = ofd.FileName;
                //保存文件名和扩展名
                Common.SafeFileName = ofd.SafeFileName;
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void time_Tick(object sender, EventArgs e)
        {
            connectServer();
        }

        /// <summary>
        /// 发送
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void btnSender_Click(object sender, EventArgs e)
        {
            //判断是否有选择用户
            string sendUser = cbList.Text;
            //获取聊天的内容
            string content = tbContent.Text;

            if (string.IsNullOrEmpty(sendUser))
            {
                //提示
                tbHis.AppendText("请选择要发送的用户...\n");
                return;
            }
            else if (string.IsNullOrEmpty(content))
            {
                //提示
                tbHis.AppendText("你不打算输入点什么咯...\n");
                return;
            }

            try
            {
                //文字： ip设置最大值为 50 位
                //[命令(1)|对方的ip和自己的ip 50位)| 内容(文字) | ...]
                //这里把对方的ip放前面是为了在服务端好获取
                //把自己的ip和对方的ip转为byte

                //如果是独立电脑应该可以这样获取
                //Common.connSocket.LocalEndPoint
                //如果此处不发送自己的ip。那么也可以在服务端获取

                string allIp = string.Format("{0},{1}", cbList.Text, myIp.Text);


                byte[] sendIp = Encoding.UTF8.GetBytes(allIp);
                byte[] buffer = Encoding.UTF8.GetBytes(content);

                List<byte> list = sendIp.ToList();
                list.Insert(0, 1);//添加协议位

                //sendIp 不够50位
                if (sendIp.Length < 50)
                {
                    for (int i = 0; i < 50 - sendIp.Length; i++)
                    {
                        list.Add(0);
                    }
                }

                //把内容添加到末尾
                list.AddRange(buffer);

                //开始发送
                Common.connSocket.Send(list.ToArray());
                tbContent.Clear();

                //把发送的内容显示在上面
                tbHis.AppendText(string.Format("时间：{0}\n", DateTime.Now.ToString()));
                tbHis.AppendText(string.Format("我对{0}说：\n", cbList.Text));
                tbHis.AppendText(content + "\n");
                tbHis.AppendText("\n");
                //清空输入框
                tbContent.Clear();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }

        }
        //保存服务器来的byte
        byte[] buffer = new byte[1024 * 1024];
        //保存ip
        public static string ip;
        void UserList_Load(object sender, EventArgs e)
        {
            connectServer();
        }

        void connectServer()
        {
            string ip = "192.168.1.2";
            int _point = 8000;

            try
            {
                Common.connSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                IPAddress address = IPAddress.Parse(ip);
                IPEndPoint point = new IPEndPoint(address, _point);
                Common.connSocket.Connect(point);

                //连接成功，获取服务器发来的消息
                Common.connSocket.BeginReceive(Common.buffer, 0, Common.buffer.Length, 0, new AsyncCallback(Receive), Common.connSocket);

                //Thread t = new Thread(get);
                //t.IsBackground = true;
                //t.Start(Common.connSocket);

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        void get(object o)
        {
            while (true)
            {
                Socket clientSocket = o as Socket;

                byte[] buffer = new byte[1024 * 1024];
                try
                {
                    //获取实际的长度
                    int num = clientSocket.Receive(buffer); //服务器关闭会报错
                    if (num > 0)
                    {
                        //获取口令
                        int command = buffer[0];
                        //说明是获取好友
                        if (command == 10)
                        {
                            //协议说明
                            //第一次登陆获取在线(好友)人数
                            //[命令(10)| ip(自己的ip和所有好友的ip)| ...]


                            //其实用户本地ip也可以这样获取
                            //string cy = clientSocket.LocalEndPoint;

                            string allIp = Encoding.UTF8.GetString(buffer, 1, num - 1);
                            string[] temp = allIp.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);


                            //跨线程操作UI
                            this.Invoke(new Action(() =>
                            {
                                myIp.Text = temp.Length > 0 ? temp[temp.Length - 1] : "";

                                //排除自己的ip
                                var other = from i in temp where !i.Contains(myIp.Text) select i;

                                cbList.Items.Clear();//清空
                                cbList.Items.AddRange(other.ToArray()); //绑定列表
                            }));

                        }
                        else if (command == 11) //说明是有人下线
                        {
                            //协议说明
                            // 有人下线
                            //[命令(11)| ip(下线的ip)| ...]

                            //获取下线的ip
                            string outIp = Encoding.UTF8.GetString(buffer, 1, num - 1);

                            this.Invoke(new Action(() =>
                            {
                                //删除下线的ip
                                cbList.Items.Remove(outIp);
                            }));
                        }
                        else if (command == 12) //有人上线了
                        {
                            //协议说明
                            // 有人上线
                            //[命令(12)| ip(上线的ip)| ...]

                            //获取上线的ip
                            string onlineIp = Encoding.UTF8.GetString(buffer, 1, num - 1);
                            //添加上线的ip

                            this.Invoke(new Action(() =>
                            {
                                //添加上线的ip
                                cbList.Items.Add(onlineIp);
                            }));

                        }

                        this.Invoke(new Action(() =>
                        {
                            if (cbList.Items.Count > 0)
                                cbList.SelectedIndex = 0;//默认选中第一个

                        }));
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                    clientSocket.Shutdown(SocketShutdown.Receive);
                    clientSocket.Close();
                    break;
                }


                //string ip = Encoding.UTF8.GetString(buffer, 0, num);
                ////MessageBox.Show(ip);

                ////第一个是自己的ip
                //string[] userIp = ip.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

                //try
                //{

                //    //cbList.Items.Clear();
                //    //MessageBox.Show(cbList.Items.Count.ToString());

                //    //var m0 = from m in userIp
                //    //         where !m.Contains(userIp[0].ToString())
                //    //         select m;
                //    //cbList.Items.AddRange(userIp.ToArray());

                //    //this.Invoke(new Action(() =>
                //    //{
                //    //    cbList.Items.Clear();
                //    //    //MessageBox.Show(cbList.Items.Count.ToString());

                //    //    cbList.Items.AddRange(userIp.ToArray());


                //    //}));
                //}
                //catch (Exception ex)
                //{
                //    MessageBox.Show(ex.Message);
                //}


                //MessageBox.Show(string.Join(",",userIp));

                //cbList.DataSource = userIp.ToList();



            }
        }

        /// <summary>
        /// 接收来自服务器的消息
        /// </summary>
        /// <param name="result"></param>
        void Receive(IAsyncResult result)
        {
            Socket clientSocket = result.AsyncState as Socket;

            //byte[] b = new byte[1024 * 1024];
            try
            {
                //获取实际的长度
                int num = clientSocket.EndReceive(result);
                if (num > 0)
                {
                    //MessageBox.Show(num.ToString());
                    byte[] buffer = new byte[num];
                    Array.Copy(Common.buffer, 0, buffer, 0, num); //复制数据到data
                    //string ip = Encoding.UTF8.GetString(data);


                    //以下是客户端=》服务器==》服务器
                    /*
                     * 当if else 超过3个
                     * 
                     * 建议用switch case语句
                     */

                    //获取口令
                    int command = buffer[0];
                    //说明是获取好友
                    if (command == 10)
                    {
                        //协议说明
                        //第一次登陆获取在线(好友)人数
                        //[命令(10)| ip(自己的ip和所有好友的ip)| ...]


                        //其实用户本地ip也可以这样获取
                        //string cy = clientSocket.LocalEndPoint;

                        string allIp = Encoding.UTF8.GetString(buffer, 1, num - 1);
                        string[] temp = allIp.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);


                        //跨线程操作UI
                        this.Invoke(new Action(() =>
                        {
                            myIp.Text = temp.Length > 0 ? temp[temp.Length - 1] : "";

                            //排除自己的ip
                            var other = from i in temp where !i.Contains(myIp.Text) select i;

                            cbList.Items.Clear();//清空
                            cbList.Items.AddRange(other.ToArray()); //绑定列表

                            if (cbList.Items.Count > 0)
                                cbList.SelectedIndex = 0;//默认选中第一个
                        }));

                    }
                    else if (command == 11) //说明是有人下线
                    {
                        //协议说明
                        // 有人下线
                        //[命令(11)| ip(下线的ip)| ...]

                        //获取下线的ip
                        string outIp = Encoding.UTF8.GetString(buffer, 1, num - 1);

                        this.Invoke(new Action(() =>
                        {
                            //删除下线的ip
                            cbList.Items.Remove(outIp);
                            if (cbList.Items.Count > 0)
                                cbList.SelectedIndex = 0;//默认选中第一个
                        }));
                    }
                    else if (command == 12) //有人上线了
                    {
                        //协议说明
                        // 有人上线
                        //[命令(12)| ip(上线的ip)| ...]

                        //获取上线的ip
                        string onlineIp = Encoding.UTF8.GetString(buffer, 1, num - 1);
                        //添加上线的ip

                        this.Invoke(new Action(() =>
                        {
                            //添加上线的ip
                            cbList.Items.Add(onlineIp);
                            if (cbList.Items.Count > 0)
                                cbList.SelectedIndex = 0;//默认选中第一个
                        }));
                    }

                    //以下是客户端=》服务器==》客户端

                    else if (command == 1)
                    {
                        //协议：
                        //[命令(1)|对方的ip和自己的ip 50位)| 内容(文字) | ...]

                        //获取ip段
                        string[] sourceIp = Encoding.UTF8.GetString(buffer, 1, 50).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

                        //发消息来的ip
                        string fromIp = sourceIp[1];



                        //获取内容
                        string content = Encoding.UTF8.GetString(buffer, 50 + 1, num - 50 - 1);

                        this.Invoke(new Action(() =>
                        {
                            //列表框中选择当前的ip
                            cbList.Text = fromIp.ToString();

                            //显示内容
                            tbHis.AppendText(string.Format("时间：{0}\n", DateTime.Now.ToString()));
                            //tbHis.AppendText(string.Format("提示{0}对我说：", fromIp)); //我操。这样怎么就不行
                            tbHis.AppendText(fromIp + "\n");
                            tbHis.AppendText("对你说：\n");
                            tbHis.AppendText(content + "\n");
                            tbHis.AppendText("\n");
                        }));
                    }
                    else if (command == 0) //发送的文件
                    {
                        /*协议: 这里50位不知道是否理想。
                         * [命令(0)| ip(对方的ip和自己的ip 50位)| 内容(文件大小和文件全名 30位)|响应(文件内容) | ...]
                         */

                        //这里有冗余代码

                        //获取ip段
                        string[] sourceIp = Encoding.UTF8.GetString(buffer, 1, 50).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

                        //发消息来的ip
                        string fromIp = sourceIp[1];

                        this.Invoke(new Action(() =>
                        {
                            //列表框中选择当前的ip
                            cbList.Text = fromIp.ToString();
                        }));


                        //获取内容
                        string content = Encoding.UTF8.GetString(buffer, 50 + 1, 30);

                        //获取响应
                        //string pass = Encoding.UTF8.GetString(buffer, 50 + 30 + 1, num - 50 - 30 - 1);

                        //显示
                        //tbHis.AppendText(string.Format("{0}给你发了一个文件：{1}\n", fromIp, content));
                        tbHis.AppendText(fromIp);
                        tbHis.AppendText("给你发了一个文件");
                        tbHis.AppendText(content + "\n");
                        tbHis.AppendText("\n");


                        //提示用户是否接收文件
                        if (MessageBox.Show("是否接受文件\n" + content, "接收文件", MessageBoxButtons.YesNo) == DialogResult.Yes)
                        {
                            //开始保存
                            SaveFileDialog sfd = new SaveFileDialog();
                            sfd.FileName = content;

                            //获取文件类型
                            string ex = content.Split('.')[1];

                            //保存文件类型
                            sfd.Filter = "|*." + ex;
                            if (sfd.ShowDialog(this) == DialogResult.OK)
                            {
                                using (FileStream fs = new FileStream(sfd.FileName, FileMode.Create))
                                {
                                    fs.Write(buffer, 50 + 30 + 1, num - 50 - 30 - 1);
                                }
                            }

                        }

                    }
                    else if (command == 2) //发送抖动
                    {
                        //如果窗口在任务栏。则显示
                        this.Show();
                        this.WindowState = FormWindowState.Normal;
                        this.Activate();

                        int n = -1;

                        for (int i = 0; i < 10; i++)
                        {
                            n = -n;
                            this.Location = new Point(this.Location.X + 10 * n, this.Location.Y + 10 * n);
                            this.TopMost = true;//在所有窗口的顶部
                            System.Threading.Thread.Sleep(50);
                        }

                        //抖动完成。结束顶层显示
                        this.TopMost = false;
                    }

                    //连接成功，再一次获取服务器发来的消息
                    clientSocket.BeginReceive(Common.buffer, 0, Common.buffer.Length, 0, new AsyncCallback(Receive), clientSocket);

                }
            }
            catch (Exception ex) //服务器端口
            {
                MessageBox.Show(ex.Message);
                clientSocket.Shutdown(SocketShutdown.Receive);
                clientSocket.Close();
            }
        }
    }
}

 

 

客户端的一个公共类 Common.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;

namespace TopClient
{
    /****************************************
     * 与服务器通信的类
    ****************************************/
    public class Common
    {
        /// <summary>
        /// 与服务器通信的socket
        /// </summary>
        public static Socket connSocket;

        /// <summary>
        /// 保存服务器来的byte
        /// </summary>
        public static byte[] buffer = new byte[1024 * 1024];

        /// <summary>
        /// 保存当登陆成功后。从服务器获取的所有用ip
        /// </summary>
        public static string ip;

        /// <summary>
        /// time计时器
        /// </summary>
        public static System.Windows.Forms.Timer time;

        /// <summary>
        /// 当前是否连接到服务器
        /// </summary>
        public static bool isConnect = false;

        /// <summary>
        /// 保存文件的文件名和扩展名 xxx.png
        /// </summary>
        public static string SafeFileName;
    }
}