1.C#网络编程(一)----应用层/传输层
2.C#网络编程(二)----网络层/链路层
3.C#网络编程(三)----HTTP协议
4.C#网络编程(四)----HttpClient
5.
C#网络编程(
五)----细嗦TCP粘包
6.C#网络编程(六)----Socket编程模型
前情提要
四层网络模型各司其职，消息(SDU)在进入每一层时都会多加一个报头(PCI)，这个PCI记录着该SDU的一些关键统计信息。SDU+PCI合并起来就组成一个完整的消息，简称为PDU
- 链路层：帧(Frame)头部作用
源 MAC 地址 和 目的 MAC 地址，用于在局域网内通信唯一标识设备，实现数据在物理链路上的传输 - 网络层：数据包(Packet)头部作用
包含 源IP 地址和 目的IP 地址，用户在互联网中实现端到端通信 - 传输层：段(Segment)/数据报(Datagram)头部作用
包含 源端口号 和 目的端口号，用于标识同一主机上的不同应用程序 - 应用层：消息(Message)头部作用
应用层协议根据具体需求定义头部格式，用于实现特定的业务逻辑
详见https://www.cnblogs.com/lmy5215006/p/18838393
数据切片
把互联网比作一条水管，那么这条水管是有一定的粗细的，而水管的粗细决定了流量的大小。因此，当我们发送"Hello World"时，当水管粗时，可以一次性发送完毕，当水管细时，就需要拆解成'He','llo','Wo','rld'。
决定"水管粗细"的由底层的数据链路层决定，为一个MTU(通常为1500Byte)，当网络层(IP)数据包<=1500byte时，一个数据包即可完成发送，如果>1500byte就需要拆分为两个数据包。
MTU（Maximum Transmission Unit，最大传输单元）
举个例子：MTU为1500byte，IP头为20Byte，IP层传输了一个3000Byte的数据包
- 第一个数据包
IP Header：20byte
Payload：1480byte
Total:1500byte - 第二个数据包
IP Header：20byte
Payload：3000byte-1480byte=1520byte (超过MTU，需要再次分片，实际1480)
Total:1500byte - 第三个数据包
IP Header：20byte
Payload：40byte
Total:60byte
由此可以看到，一次传输被拆分成了三次，每个分配重复携带IP Header，增加了额外的传输冗余，且分配需要重组，增加了延迟与丢包风险。
MTU与MSS
为了缓解上述的问题，传输层的TCP协议通过MSS(Maximum Segment Size,最大段大小)来避免IP分片。
- 三次握手协商
三次握手时，双方通过SYN报文交换MSS值，确保Segment 不超过MSS。
MSS=MTU-IP Header-TCP Header，比如MTU=1500，那么MSS=1500-20-20=1460byte。 - 路径MTU发现
IP协议通过ICMP协议探测传输路径中的最小MTU，动态调整数据包大小以减少分片。
通过动态协商MTU，使得IP数据包使用不会超过MTU的值，从而避免了分片。不会出现MTU=1500，IP数据包3000Byte的现象。
粘包
人生就像打电话，不是你挂就是我挂。
切片也是，你链路层倒是爽了，不用拆包了，但传输层就遭殃了，因为总要有人负重前行。
TCP是一种面向连接，可靠的，基于字节流的传输层通信协议，因为基于字节流的特点，数据由01组成，所以当我们在互联网中传输"hello World"时，是以0101010101这种格式的字节流发送。
这些二进制数据，对于接收端来说，不知道要接收多少才能组成一个消息，因此其本质是应用层消息边界在TCP流中消失。
粘包发生的原因如下：
- 数据包过小
当Segment特别小，没有达到MSS的标准，TCP的Nagle算法会原地等待200ms，等下一个包一起发送。 - 数据包过大
如果下一个包来之后，超过了MSS的标准，则会拆包。 - 接收端读取数据不及时
接收端处理不及时，导致在Buff中好几个Segment的先后粘在一起，导致接收端无法区分。
说白了，粘包不是TCP的设计缺陷，而是一种取舍。
眼见为实
如何解决粘包
既然原理知道了，那么解决它也很简单.
- 消息定长
每个数据包的长度固定，那么接收端只要固定读取特定长度的二进制流即可区分。 - 分割符标记
通过特殊标记作为头/尾，比如EOF，回车，0xffffff等。当接收端处理到特殊标记时，就知道消息读取完了。 - 头部包含长度字段
一般会配合上面的分割符标记来加强，在Header中加入消息长度，然后就如同消息定长一样读取即可。
如果某个数据里正好有EOF怎么办？
还有标志位作为兜底，发送端在发送时加入16校验和(对完整数据进行CRC)，以供接收端校验。
如同文件的MD5一样，下载完成后校验MD5，避免错误。
眼见为实
- 消息定长
//方法1,消息定长,假设消息固定长度为10
if(length==10)
{
var temp = new byte[length];
Array.Copy(buffer, 0, temp, 0, length);
this.Dispatcher.Invoke(() =>
{
Message.Add(Encoding.ASCII.GetString(temp));
});
}
- 分割符标记
//方法2，分割符标记,假设分割符是|
var eof = Encoding.UTF8.GetBytes("|");
int eofIndex = Array.IndexOf(buffer, eof[0], 0, length);
if (eofIndex > 0)
{
var temp = new byte[length];
Array.Copy(buffer, 0, temp, 0, length);
this.Dispatcher.Invoke(() =>
{
Message.Add(Encoding.ASCII.GetString(temp).Substring(0,eofIndex));
});
}
- 头部包含长度字段
//方法3，头部包含长度
var temp = new byte[length];
Array.Copy(buffer, 0, temp, 0, length);
var str= Encoding.UTF8.GetString(temp);
var headerLength = int.Parse(str.Substring(0, 2));
this.Dispatcher.Invoke(() =>
{
Message.Add(str.Substring(2, headerLength)) ;
});
注意，这里只是示例，只是简单的把黏在一起的数据拆分，并把多余的丢弃。正式环境还有很多要额外处理的。
FAQ
UDP会有粘包问题吗?
不会，原因如下:
- UDP 不存在合并数据的机制
Datagram是独立的数据单元，是最小单位，包含完整的Head和Payload。接收方要设置合理的缓冲区来接收，否则数据会丢失。
当Datagram，网络层(IP层)会对其分片，但传输层本身不处理分片。 - Datagram边界明确
UDP 协议保证接收方可以通过数据报的长度字段（头部中 Length 字段）准确区分每个数据包的起始和结束。
简单来说，UDP自己都不保证消息消息完整，就算发生粘包又怎么样呢？
网络层会有粘包问题吗?
虽然我们在传输层明确了MSS会小于MTU(1500byte)，避免了IP层的大包分片，但还会有漏网之鱼。比如在动态路径MTU发现中，发现某个路由器MTU只有500byte，那么IP层也需要对数据包进行切片。
再此之后会重新协商，传输层会调整MSS为500byte。
回到正题，那么网络层会有粘包问题吗?
答案是不会，再次强调一遍粘包本质是应用层消息边界在TCP流中消失。网络层只负责数据切片以及数据重组，它不关心里面的内容是什么，只是数据的搬运工，因此不会发生粘包。
关闭Nagle算法会减少粘包吗？
关闭Nagle算法会减少粘包，因为小的数据包会立即发送，而不是等200ms。
但治标不治本，接收方处理速度慢也是粘包的一个原因。
源码，包含了完整的粘包处理
MainWindow
<Window x:Class="WpfSocketServer.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:local="clr-namespace:WpfSocketServer"
mc:Ignorable="d"
Title="WPF Socket 服务器（粘包处理）" Height="500" Width="800">
<Grid Margin="10">
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="*"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<!-- 控制按钮 -->
<StackPanel Grid.Row="0" Orientation="Horizontal" Margin="0 0 0 10">
<Button x:Name="btnStart" Content="启动服务器" Width="100" Click="BtnStart_Click"
Margin="0 0 10 0" Padding="5"/>
<TextBlock x:Name="txtStatus" Text="状态：未启动" VerticalAlignment="Center"/>
<Button Grid.Column="0" Width="100" Margin="10 0 0 0" Padding="5" Content="清空" Click="Button_Click">
</Button>
</StackPanel>
<!-- 消息显示列表 -->
<ListView Grid.Row="1" ItemsSource="{Binding Messages}" Margin="0 5 0 5">
<ListView.View>
<GridView>
<GridViewColumn Header="时间" Width="120"
DisplayMemberBinding="{Binding Time}"/>
<GridViewColumn Header="来源" Width="150"
DisplayMemberBinding="{Binding Source}"/>
<GridViewColumn Header="内容" Width="450"
DisplayMemberBinding="{Binding Content}"/>
</GridView>
</ListView.View>
</ListView>
<!-- 状态提示 -->
<TextBlock Grid.Row="2" Text="注：使用长度前缀法（4字节头部）处理粘包，支持多客户端连接"
Foreground="Gray" FontSize="12"/>
</Grid>
</Window>
MainWindow.xaml.cs
using System.Windows;
using System.Net;
using WpfApp1;
namespace WpfSocketServer
{
public partial class MainWindow : Window
{
private readonly MainViewModel _viewModel = new MainViewModel();
private SocketServer _socketServer;
public MainWindow()
{
InitializeComponent();
DataContext = _viewModel; // 绑定 ViewModel
}
// 启动/停止服务器按钮点击事件
private async void BtnStart_Click(object sender, RoutedEventArgs e)
{
if (_socketServer == null || !_socketServer.IsRunning())
{
btnStart.Content = "停止服务器";
// 启动服务器（监听 127.0.0.1:6666）
_socketServer = new SocketServer(_viewModel);
await _socketServer.StartAsync(new IPEndPoint(IPAddress.Loopback, 6666));
}
else
{
// 停止服务器
_socketServer.Stop();
btnStart.Content = "启动服务器";
}
}
/// <summary>
/// 清空ViewList
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Button_Click(object sender, RoutedEventArgs e)
{
if (_viewModel.Messages?.Count > 0)
{
_viewModel.Messages.Clear();
}
else
{
MessageBox.Show("已经为空", "tips");
}
}
}
// 扩展：检查服务器是否运行（添加到 SocketServer 类）
public static class SocketServerExtensions
{
public static bool IsRunning(this SocketServer server)
{
return server?._isRunning ?? false;
}
}
}
MessageItem
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
namespace WpfApp1
{
// 消息项模型（用于 ListView 显示）
public class MessageItem : INotifyPropertyChanged
{
public DateTime Time { get; set; } // 时间戳
public string? Source { get; set; } // 客户端来源（IP:Port）
public string? Content { get; set; } // 消息内容
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
}
// 主 ViewModel
public class MainViewModel : INotifyPropertyChanged
{
private ObservableCollection<MessageItem> _messages = new ObservableCollection<MessageItem>();
// 消息集合（绑定到 ListView）
public ObservableCollection<MessageItem> Messages
{
get => _messages;
set
{
_messages = value;
OnPropertyChanged();
}
}
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
}
}
WpfSocketServer
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using WpfApp1;
namespace WpfSocketServer
{
public class SocketServer : IDisposable
{
private Socket _serverSocket;
private readonly MainViewModel _viewModel;
public bool _isRunning;
public SocketServer(MainViewModel viewModel)
{
_viewModel = viewModel;
}
// 启动服务器（异步）
public async Task StartAsync(IPEndPoint endPoint)
{
if (_isRunning) return;
try
{
_serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_serverSocket.Bind(endPoint);//绑定端口
_serverSocket.Listen(5); // 最大等待连接数
_isRunning = true;
UpdateStatus("服务器已启动，等待客户端连接...");
// 异步接受客户端连接（循环）
while (_isRunning)
{
Socket clientSocket = await _serverSocket.AcceptAsync();
var clientInfo = clientSocket.RemoteEndPoint?.ToString();
UpdateMessage(new MessageItem
{
Time = DateTime.Now,
Source = clientInfo,
Content = "客户端已连接"
});
// 为每个客户端启动独立接收任务
_ = Task.Run(() => HandleClientAsync(clientSocket));
}
}
catch (Exception ex)
{
if (_isRunning) // 非主动停止时显示错误
UpdateStatus($"服务器异常: {ex.Message}");
}
}
/// <summary>
/// 核心逻辑:
/// 当滑动窗口的数据不足以组成一个完整的数据包时(header+body)，暂时保留当前数据，等候后续追加。
/// </summary>
/// <param name="clientSocket"></param>
/// <returns></returns>
private async Task HandleClientAsync(Socket clientSocket)
{
var clientInfo = clientSocket.RemoteEndPoint?.ToString();
List<byte> receiveBuffer = new List<byte>(); // 处理粘包的缓冲区，可以使用Memory<byte>来优化，我偷个懒。
try
{
byte[] buffer = new byte[1024];
while (clientSocket.Connected)
{
// 从内核态的滑动窗口中读取字节流到缓冲区
int readBytesLength = await clientSocket.ReceiveAsync(buffer, SocketFlags.None);
if (readBytesLength == 0) break;
UpdateMessage(new MessageItem
{
Time = DateTime.Now,
Source = clientInfo,
Content = $"本次接收原始字节数: {readBytesLength}（可能包含多个包）"
});
receiveBuffer.AddRange(new ArraySegment<byte>(buffer, 0, readBytesLength));
while (receiveBuffer.Count >= 4)
{
// 解析head，得出body长度
byte[] headerBytes = receiveBuffer.GetRange(0, 4).ToArray();
if (BitConverter.IsLittleEndian) Array.Reverse(headerBytes);
int bodyBytesLength = BitConverter.ToInt32(headerBytes, 0);
//数据如果不足够，则退出循环，保留当前数据，等待下次接收新数据后再次尝试解析
if (receiveBuffer.Count < (4 + bodyBytesLength)) break;
// 解析body
byte[] bodyBytes = receiveBuffer.GetRange(4, bodyBytesLength).ToArray();
string message = Encoding.UTF8.GetString(bodyBytes);
//数据如果足够，则提取数据、更新 UI，并从缓冲区移除已处理的数据。
UpdateMessage(new MessageItem
{
Time = DateTime.Now,
Source = clientInfo,
Content = $"解析后数据包: {message}"
});
// 移除已处理的数据
receiveBuffer.RemoveRange(0, 4 + bodyBytesLength);
}
}
// 客户端断开连接
UpdateMessage(new MessageItem
{
Time = DateTime.Now,
Source = clientInfo,
Content = "客户端断开连接"
});
}
catch (Exception ex)
{
UpdateMessage(new MessageItem
{
Time = DateTime.Now,
Source = clientInfo,
Content = $"接收异常: {ex.Message}"
});
}
finally
{
clientSocket.Close();
}
}
// 安全更新 UI 消息（通过 Dispatcher）
private void UpdateMessage(MessageItem message)
{
Application.Current.Dispatcher.Invoke(() =>
{
_viewModel.Messages.Add(message);
});
}
// 更新状态文本
private void UpdateStatus(string text)
{
Application.Current.Dispatcher.Invoke(() =>
{
// 假设窗口中 txtStatus 是 TextBlock，需在窗口后台绑定此方法
// 实际使用中可通过 ViewModel 暴露状态属性
if (Application.Current.MainWindow is MainWindow mainWindow)
mainWindow.txtStatus.Text = $"状态：{text}";
});
}
// 停止服务器
public void Stop()
{
_isRunning = false;
_serverSocket?.Close();
UpdateStatus("服务器已停止");
}
// 释放资源
public void Dispose()
{
Stop();
}
}
}
产生粘包的Client
using System.Net.Sockets;
using System.Net;
using System.Text;
namespace SocketReceiveClient
{
internal class Program
{
static void Main()
{
var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
client.Connect(IPAddress.Loopback, 6666); // 连接你的 WPF 服务器
Console.WriteLine("已连接服务器，开始发送粘包数据...");
// 连续发送 3 个小数据包（间隔 50ms，触发 TCP 粘包）
for (int i = 0;i<=100;i++)
{
SendPacket(client, $"{Guid.NewGuid()}");
}
client.Close();
Console.WriteLine("数据发送完成，按任意键退出...");
Console.ReadKey();
}
// 发送带长度头的数据包（与服务器协议一致）
static void SendPacket(Socket client, string message)
{
byte[] rawData = Encoding.UTF8.GetBytes(message);
byte[] lengthHeader = BitConverter.GetBytes(rawData.Length);
if (BitConverter.IsLittleEndian) Array.Reverse(lengthHeader); // 大端模式
byte[] sendBuffer = new byte[4 + rawData.Length];
Buffer.BlockCopy(lengthHeader, 0, sendBuffer, 0, 4);
Buffer.BlockCopy(rawData, 0, sendBuffer, 4, rawData.Length);
client.Send(sendBuffer);
Console.WriteLine($"已发送: {message}");
}
}
}
扫一扫
1416
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
