Socket 通信（基础原理、实时聊天系统雏形）

什么是 Socket？

Socket 英文直译为“孔或插座”，也称为套接字。用于描述 IP 地址和端口号，是一种进程间的通信机制。你可以理解为 IP 地址确定了网内的唯一计算机，而端口号则指定了将消息发送给哪一个应用程序（大多应用程序启动时会主动绑定一个端口，如果不主动绑定，操作系统自动为其分配一个端口）。

 

什么是端口？

一台主机一般运行了多个软件并同时提供一些服务。每种服务都会打开一个 Socket，并绑定到一个端口号上，不同端口对应于不同的应用程序。例如 http 使用 80 端口；ftp 使用 21 端口；smtp 使用 23 端口。

 

Socket 的类型

• Stream：一种流式 Socket，针对于面向连接的 TCP 服务应用，安全，但效率低。（本文重点）
• Datagram：数据报式的 Socket，针对于无连接的 UDP 服务应用，不安全（丢失、顺序混乱，往往在接收端要分析完整性、重排、或要求重发），但效率高。

 

Socket 程序一般应用模式及运行流程

1. 服务器端会启动一个 Socket，开始监听端口，监听客户端的连接信息，我们称之为 Watch Socket。
2. 客户端 Socket 连接服务器端的监听 Socket，一旦成功连接，服务器端会立刻创建一个新的 Socket 负责与客户端进行通信，之后，客户端将不再与 Watch Socket 通信。
3. Watch Socket 继续监听可能会来自其他客户端的连接。

上述过程就像是实现了一次三方会谈。服务器端的 Socket 至少会有 2 个。一个是 Watch Socket，每成功接收到一个客户端的连接，便在服务器端创建一个通信 Socket。客户端 Socket 指定要连接的服务器端地址和端口，创建一个 Socket 对象来初始化一个到服务器的 TCP 连接。

 

通信的雏形

下面就看一个最简单的 Socket 示例，实现了网络聊天通信的雏形。

服务器端：

public partial class ChatServer : Form
    {
        public ChatServer()
        {
            InitializeComponent();
            ListBox.CheckForIllegalCrossThreadCalls = false;
        }

        /// <summary>
        /// 监听 Socket 运行的线程
        /// </summary>
        Thread threadWatch = null;

        /// <summary>
        /// 监听 Socket
        /// </summary>
        Socket socketWatch = null;

        /// <summary>
        /// 服务器端通信套接字集合
        /// 必须在每次客户端连接成功之后，保存新建的通讯套接字，这样才能和后续的所有客户端通信
        /// </summary>
        Dictionary<string, Socket> dictCommunication = new Dictionary<string, Socket>();

        /// <summary>
        /// 通信线程的集合，用来接收客户端发送的信息
        /// </summary>
        Dictionary<string, Thread> dictThread = new Dictionary<string, Thread>();

        private void btnBeginListen_Click(object sender, EventArgs e)
        {
            // 创建服务器端监听 Socket (IP4寻址协议，流式连接，TCP协议传输数据)
            socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            // 监听套接字绑定指定端口
            IPAddress address = IPAddress.Parse(txtIP.Text.Trim());
            IPEndPoint endPoint = new IPEndPoint(address, int.Parse(txtPort.Text.Trim()));
            socketWatch.Bind(endPoint);

            // 将监听套接字置于侦听状态，并设置连接队列的最大长度
            socketWatch.Listen(20);

            // 启动监听线程开始监听客户端请求
            threadWatch = new Thread(Watch);
            threadWatch.IsBackground = true;
            threadWatch.Start();
            ShowMsg("服务器启动完成！");
        }

        Socket socketCommunication = null;
        private void Watch()
        {
            while (true)
            {
                // Accept() 会创建新的通信 Socket，且会阻断当前线程，因此应置于非主线程上使用
                // Accept() 与线程上接受的委托类型不符，因此需另建一方法做桥接
                socketCommunication = socketWatch.Accept();

                // 将新建的通信套接字存入集合中，以便服务器随时可以向指定客户端发送消息
                // 如不置于集合中，每次 new 出的通信线程都是一个新的套接字，那么原套接字将失去引用
                dictCommunication.Add(socketCommunication.RemoteEndPoint.ToString(), socketCommunication);
                lbSocketOnline.Items.Add(socketCommunication.RemoteEndPoint.ToString());

                // Receive 也是一个阻塞方法，不能直接运行在 Watch 中，否则监听线程会阻塞
                // 另外，将每一个通信线程存入集合，方便今后的管理（如关闭、或挂起）
                Thread thread = new Thread(() =>
                {
                    while (true)
                    {
                        byte[] bytes = new byte[1024 * 1024 * 2];
                        int length =  socketCommunication.Receive(bytes);
                        string msg = Encoding.UTF8.GetString(bytes, 0, length);
                        ShowMsg("接收到来自" + socketCommunication.RemoteEndPoint.ToString() + "的数据：" + msg);
                    }
                });
                thread.IsBackground = true;
                thread.Start();
                dictThread.Add(socketCommunication.RemoteEndPoint.ToString(), thread);

                ShowMsg("客户端连接成功！通信地址为：" + socketCommunication.RemoteEndPoint.ToString());
            }
        }

        delegate void ShowMsgCallback(string msg);
        private void ShowMsg(string msg)
        {
            if (this.InvokeRequired) // 也可以启动时修改控件的 CheckForIllegalCrossThreadCalls 属性
            {
                this.Invoke(new ShowMsgCallback(ShowMsg), new object[] { msg });
            }
            else
            {
                this.txtMsg.AppendText(msg + "\r\n");
            }
        }

        private void btnSendMsg_Click(object sender, EventArgs e)
        {
            if (lbSocketOnline.Text.Length == 0)
                MessageBox.Show("至少选择一个客户端才能发送消息！");
            else
            {
                // Send() 只接受字节数组
                string msg = txtSendMsg.Text.Trim();
                dictCommunication[lbSocketOnline.Text].Send(Encoding.UTF8.GetBytes(msg));
                ShowMsg("发送数据：" + msg);
            }
        }

        private void btnSendToAll_Click(object sender, EventArgs e)
        {
            string msg = txtSendMsg.Text.Trim();
            foreach (var socket in dictCommunication.Values)
            {
                socket.Send(Encoding.UTF8.GetBytes(msg));
            }
            ShowMsg("群发数据：" + msg);
        }
    }

客户端：

public partial class ChatClient : Form
    {
        public ChatClient()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 此线程用来接收服务器发送的数据
        /// </summary>
        Thread threadRecive = null;

        Socket socketClient = null;

        private void btnConnect_Click(object sender, EventArgs e)
        {
            // 客户端创建通讯套接字并连接服务器、开始接收服务器传来的数据
            socketClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            socketClient.Connect(IPAddress.Parse(txtIP.Text.Trim()), int.Parse(txtPort.Text.Trim()));
            ShowMsg(string.Format("连接服务器（{0}:{1}）成功！", txtIP.Text.Trim(), txtPort.Text.Trim()));

            threadRecive = new Thread(new ThreadStart(() =>
            {
                while (true)
                {
                    // Receive 方法从套接字中接收数据，并存入接收缓冲区
                    byte[] bytes = new byte[1024 * 1024 * 2];
                    int length = socketClient.Receive(bytes);
                    string msg = Encoding.UTF8.GetString(bytes, 0, length);
                    ShowMsg("接收到数据：" + msg);
                }
            }));
            threadRecive.IsBackground = true;
            threadRecive.Start();
        }

        delegate void ShowMsgCallback(string msg);
        private void ShowMsg(string msg)
        {
            if (this.InvokeRequired) // 也可以启动时修改控件的 CheckForIllegalCrossThreadCalls 属性
            {
                this.Invoke(new ShowMsgCallback(ShowMsg), new object[] { msg });
            }
            else
            {
                this.txtMsg.AppendText(msg + "\r\n");
            }
        }

        private void btnSend_Click(object sender, EventArgs e)
        {
            string msg = txtSendMsg.Text.Trim();
            socketClient.Send(Encoding.UTF8.GetBytes(msg));
            ShowMsg("发送数据：" + msg);
        }
    }

现在所有客户都能和服务器进行通信，服务器也能和所有客户进行通信。那么，客户端之间互相通信呢？

显然，在客户端界面也应创建在线列表，每次有人登录后，服务器端除了刷新自身在线列表外，还需将新客户端的套接字信息发送给其他在线客户端，以便它们更新自己的在线列表。

客户端发送消息给服务器，服务器转发此消息给另一个客户端。当然，这个消息需要进行一些处理，至少要包含目标套接字和发送内容。

更为完善的是，服务器必须定时按制定的规则检测列表中套接字通信的有效性，通过发送响应信号，并接收客户端应答信号以确认客户端的连接性是真实的（否则，需剔除无效客户端）。

 

客户端上传文件

客户端：

private void btnChooseFile_Click(object sender, EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            if (ofd.ShowDialog() == DialogResult.OK)
            {
                txtFilePath.Text = ofd.FileName;
            }
        }

        private void btnSendFile_Click(object sender, EventArgs e)
        {
            using (FileStream fs = new FileStream(txtFilePath.Text, FileMode.Open))
            {
                byte[] bytes = new byte[1024 * 1024 * 2];

                // 假设第一个字节为标志位：0 表示传送文件

                // 方式一：整体向后偏移 1 个字节；但这样有潜在缺点，
                // 有时在通信时会非常准确的按照约定的字节长度来传递，
                // 那么这种偏移方案显然是不可靠的
                // bytes[0] = 0;
                // int length = fs.Read(bytes, 1, bytes.Length);

                // 方式二：创建多出 1 个字节的数组发送
                int length = fs.Read(bytes, 0, bytes.Length);
                byte[] newBytes = new byte[length + 1];
                newBytes[0] = 0;
                // BlockCopy() 会比你自己写for循环赋值更为简单合适
                Buffer.BlockCopy(bytes, 0, newBytes, 1, length);
                socketClient.Send(newBytes);
            }
        }

服务器端（Receive 方法中修改成这样）：

Thread thread = new Thread(() =>
                {
                    while (true)
                    {
                        byte[] bytes = new byte[1024 * 1024 * 2];
                        int length =  socketCommunication.Receive(bytes);

                        if (bytes[0] == 0) // File
                        {
                            SaveFileDialog sfd = new SaveFileDialog();
                            if (sfd.ShowDialog() == DialogResult.OK)
                            {
                                using (FileStream fs = new FileStream(sfd.FileName, FileMode.Create))
                                {
                                    fs.Write(bytes, 1, length - 1);
                                    fs.Flush();
                                    ShowMsg("文件保存成功，路径为：" + sfd.FileName);
                                }
                            }
                        }
                        else // Msg
                        {
                            string msg = Encoding.UTF8.GetString(bytes, 0, length);
                            ShowMsg("接收到来自" + socketCommunication.RemoteEndPoint.ToString() + "的数据：" + msg);
                        }
                    }
                });

 

异常捕捉

Socket 通信属于网络通信程序，会有许多的意外，必须进行异常处理以便程序不会被轻易的击垮。不管是客户端还是服务器端，只要和网络交互的环节（Connect、Accept、Send、Receive 等）都要做异常处理。

本例中对服务器端 Receive 方法环节做了一些异常处理，并移除了相应的资源，例如下面：

try
{
    length = socketCommunication.Receive(bytes);
}
catch (SocketException ex)
{
    ShowMsg("出现异常：" + ex.Message);
    string key = socketCommunication.RemoteEndPoint.ToString();
    lbSocketOnline.Items.Remove(key);
    dictCommunication.Remove(key);
    dictThread.Remove(key);
    break;
}

 

系统界面截图

 

9