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;
}

 

系统界面截图

image

 

image image 9

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值