-
C#网络编程之.NET网络实现（CoreCLR、System.Net）
第69章 .NET网络实现（CoreCLR、System.Net）
一、我踩过的.NET网络坑：从“HttpClient创建1000次导致端口耗尽”到“CoreCLR下Socket性能比Framework高3倍”
做微服务网关时，一开始每个请求都new HttpClient()，结果上线1小时就炸了——服务器报“端口耗尽”，netstat一看全是TIME_WAIT状态的Socket。查了半天才明白：HttpClient默认用连接池，频繁创建实例会导致连接池被占满，每个实例都开新连接，用完也不释放。后来改成单例复用HttpClient，端口使用率直接从90%降到10%！还有一次把Framework的Socket服务器迁到CoreCLR，相同并发下CPU从80%掉到20%，性能翻了3倍——原来CoreCLR的Socket底层重写了，去掉了Framework的历史包袱，Windows用IOCP、Linux用epoll，效率拉满。这节我把这些血泪经验揉进去，用大vb.net教程C#教程python教程SQL教程access 2010教程白话讲透.NET网络栈的架构，结合CoreCLR底层实现和System.Net代码逐行拆解，拓展跨平台适配、性能优化的核心知识，让你不仅会用.NET网络API，还懂它到底是怎么跑的！
二、大白话讲.NET网络栈：CoreCLR是“翻译官”，System.Net是“API工具箱”
.NET网络栈四层架构（从上层到底层）
1.你的代码：比如用HttpClient发请求、用Socket写服务器；
2.System.Net：.NET给你准备的“网络工具箱”，封装了Socket、HTTP、TCP等复杂操作，不用你直接和操作系统打交道；
3.CoreCLR网络层：.NET运行时的“翻译官”，把System.Net的API转换成操作系统能听懂的指令（比如Windows的Winsock、Linux的Socket API）；
4.操作系统网络栈：最终和网卡交互的底层，比如Windows的Winsock、Linux的TCP/IP协议栈。
大白话类比：你要给国外客户发邮件（应用层），System.Net是“邮件客户端”（帮你写邮件、填地址），CoreCLR是“翻译”（把中文邮件翻译成英文），操作系统网络栈是“邮局”（把邮件寄到客户手里）。
三、System.Net核心组件解析：每个组件都是“开箱即用的工具”
-
Socket：最底层的“螺丝刀”，直接拧操作系统的网络螺丝
作用：对应操作系统的Socket，是所有.NET网络组件的基础（TcpListener、HttpClient都是基于Socket封装的）；
底层实现：CoreCLR会根据操作系统调用不同的API——Windows下叫WSASocket()，Linux下叫socket()；
我踩过的坑：Framework的SocketAsyncEventArgs在高并发下会内存泄漏，CoreCLR修复了这个bug，现在用它跑10万连接都不卡。 -
TcpListener/TcpClient：TCP开发的“快捷扳手”
作用：封装了Socket的TCP操作，比如监听连接、收发数据，比直接用Socket简单10倍；
底层实现：内部就是Socket——比如TcpListener.AcceptTcpClient()其实就是调用Socket.Accept()，再包装成TcpClient；
拓展知识：CoreCLR的TcpListener支持异步方法AcceptTcpClientAsync()，底层用IOCP/epoll实现，性能和直接用SocketAsyncEventArgs差不多，但代码简单很多。 -
HttpClient：HTTP客户端的“瑞士军刀”
作用：发HTTP/HTTPS请求，自动处理连接池、Cookie、重定向，不用你自己拼HTTP头；
底层实现：内部用SocketsHttpHandler，而SocketsHttpHandler是用Socket实现的HTTP协议解析；
我踩过的坑：千万不要每次请求都new HttpClient()！会导致连接池耗尽，端口不够用。要么用单例，要么用IHttpClientFactory（.NET Core 2.1+推荐）。 -
SignalR：实时通信的“魔法棒”
作用：封装了WebSocket、Server-Sent Events、Long Polling，自动选最佳传输方式，不用你自己判断客户端支持什么；
底层实现：WebSocket用Socket，Long Polling用HttpClient；
拓展知识：CoreCLR的SignalR在Linux下用epoll处理WebSocket连接，性能比Framework高2倍，跨平台跑起来丝滑得很。
四、实战：CoreCLR下SocketAsyncEventArgs高性能服务器代码逐行讲解
核心代码：1个线程扛10万连接的TCP服务器
csharp
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
namespace CoreClrHighPerfSocket;
class HighPerfTcpServer
{
private readonly Socket _listenSocket;
private readonly SocketAsyncEventArgsPool _acceptPool;
private readonly SocketAsyncEventArgsPool _receivePool;
private readonly int _maxConnections;
private int _currentConnections;
public HighPerfTcpServer(int maxConnections)
{
_maxConnections = maxConnections;
_currentConnections = 0;
// 1. 创建监听Socket：CoreCLR底层会调用操作系统的socket() API
// AddressFamily.InterNetwork：IPv4
// SocketType.Stream：流式Socket，对应TCP
// ProtocolType.Tcp：TCP协议
_listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// 端口复用：解决服务器重启时端口被TIME_WAIT占用的问题
_listenSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
// 禁用Nagle算法：实时通信场景减少延迟，大文件传输可以开启
_listenSocket.NoDelay = true;
Console.WriteLine("1. 创建监听Socket，底层分配操作系统Socket资源");
// 2. 初始化SocketAsyncEventArgs池：复用对象，减少GC
// 为什么要池化？因为创建SocketAsyncEventArgs会分配操作系统资源，频繁创建销毁会导致GC爆炸
_acceptPool = new SocketAsyncEventArgsPool(maxConnections / 10); // 接受连接的池，不用太大
_receivePool = new SocketAsyncEventArgsPool(maxConnections); // 接收数据的池，和最大连接数一致
for (int i = 0; i < maxConnections / 10; i++)
{
var acceptArgs = new SocketAsyncEventArgs();
acceptArgs.Completed += AcceptCompleted; // 绑定完成事件
_acceptPool.Push(acceptArgs);
}
for (int i = 0; i < maxConnections; i++)
{
var receiveArgs = new SocketAsyncEventArgs();
receiveArgs.Completed += ReceiveCompleted;
receiveArgs.SetBuffer(new byte[4096], 0, 4096); // 设置接收缓冲区4KB
_receivePool.Push(receiveArgs);
}
Console.WriteLine("2. 初始化SocketAsyncEventArgs池，准备处理高并发连接");
}
public void Start(IPAddress ip, int port)
{
// 3. 绑定IP和端口：CoreCLR底层调用bind() API
_listenSocket.Bind(new IPEndPoint(ip, port));
// 4. 开始监听：CoreCLR底层调用listen() API，backlog设为最大连接数
_listenSocket.Listen(_maxConnections);
Console.WriteLine($"3. 服务器启动成功，监听端口{port}，最大连接数{_maxConnections}");
// 5. 开始异步接受连接：CoreCLR底层用IOCP（Windows）或epoll（Linux）实现
StartAccept();
}
private void StartAccept()
{
SocketAsyncEventArgs acceptArgs = _acceptPool.Pop();
if (acceptArgs == null)
{
// 池里没有就新建，避免阻塞
acceptArgs = new SocketAsyncEventArgs();
acceptArgs.Completed += AcceptCompleted;
}
// AcceptAsync是异步非阻塞方法，不会卡线程
// 返回true表示操作异步完成，会触发Completed事件；返回false表示操作同步完成，直接处理
bool willRaiseEvent = _listenSocket.AcceptAsync(acceptArgs);
if (!willRaiseEvent)
{
ProcessAccept(acceptArgs);
}
}
private void AcceptCompleted(object sender, SocketAsyncEventArgs e)
{
// 异步接受连接完成，触发这个事件
ProcessAccept(e);
}
private void ProcessAccept(SocketAsyncEventArgs e)
{
if (e.SocketError != SocketError.Success)
{
Console.WriteLine($"接受连接失败：{e.SocketError}");
_acceptPool.Push(e); // 放回池里复用
StartAccept(); // 继续接受下一个连接
return;
}
if (_currentConnections >= _maxConnections)
{
Console.WriteLine("超过最大连接数，拒绝新连接");
e.AcceptSocket.Close();
_acceptPool.Push(e);
StartAccept();
return;
}
// 原子操作增加连接数，避免多线程冲突
Interlocked.Increment(ref _currentConnections);
var clientEndPoint = (IPEndPoint)e.AcceptSocket.RemoteEndPoint;
Console.WriteLine($"客户端 {clientEndPoint.Address}:{clientEndPoint.Port} 连接成功，当前连接数{_currentConnections}");
// 开始异步接收客户端数据
SocketAsyncEventArgs receiveArgs = _receivePool.Pop();
receiveArgs.UserToken = e.AcceptSocket; // 把客户端Socket存在UserToken里
bool willRaiseReceiveEvent = e.AcceptSocket.ReceiveAsync(receiveArgs);
if (!willRaiseReceiveEvent)
{
ProcessReceive(receiveArgs);
}
// 把AcceptArgs放回池里，继续接受下一个连接
_acceptPool.Push(e);
StartAccept();
}
private void ReceiveCompleted(object sender, SocketAsyncEventArgs e)
{
ProcessReceive(e);
}
private void ProcessReceive(SocketAsyncEventArgs e)
{
Socket clientSocket = (Socket)e.UserToken;
if (e.SocketError != SocketError.Success || e.BytesTransferred == 0)
{
// 客户端断开连接，或者出错了
clientSocket.Close();
Interlocked.Decrement(ref _currentConnections);
_receivePool.Push(e); // 放回池里复用
Console.WriteLine($"客户端断开连接，当前连接数{_currentConnections}");
return;
}
// 处理收到的数据：把字节转成字符串
string message = Encoding.UTF8.GetString(e.Buffer, 0, e.BytesTransferred);
Console.WriteLine($"收到消息：{message}");
// 发送回复消息：这里用同步Send，高并发场景建议用SendAsync
string response = $"服务器收到：{message}";
byte[] responseBuffer = Encoding.UTF8.GetBytes(response);
clientSocket.Send(responseBuffer);
// 继续异步接收下一批数据
bool willRaiseReceiveEvent = clientSocket.ReceiveAsync(e);
if (!willRaiseReceiveEvent)
{
ProcessReceive(e);
}
}
}
// SocketAsyncEventArgs池：复用对象，减少GC和操作系统资源开销
public class SocketAsyncEventArgsPool
{
private readonly Queue<SocketAsyncEventArgs> _pool;
public SocketAsyncEventArgsPool(int capacity)
{
_pool = new Queue<SocketAsyncEventArgs>(capacity);
}
public void Push(SocketAsyncEventArgs args)
{
if (args == null) throw new ArgumentNullException(nameof(args));
lock (_pool) // 加锁保证线程安全
{
_pool.Enqueue(args);
}
}
public SocketAsyncEventArgs Pop()
{
lock (_pool)
{
return _pool.Count > 0 ? _pool.Dequeue() : null;
}
}
}
// 测试代码
class Program
{
static void Main(string[] args)
{
// 启动一个支持10000个并发连接的服务器
var server = new HighPerfTcpServer(10000);
server.Start(IPAddress.Any, 8888);
Console.WriteLine("按任意键停止服务器...");
Console.ReadKey();
}
}
代码逐行拆解（结合CoreCLR底层实现）
-
创建监听Socket
csharp
_listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
CoreCLR底层动作：
Windows：调用WSASocket() API，创建一个Socket句柄；
Linux：调用socket()系统调用，返回一个文件描述符；
拓展知识：CoreCLR的Socket支持跨平台，代码不用改就能在Windows、Linux、macOS上跑。 -
池化SocketAsyncEventArgs
csharp
_receivePool = new SocketAsyncEventArgsPool(maxConnections);
我踩过的坑：之前不用池化，每次创建SocketAsyncEventArgs，结果高并发下GC疯狂触发，CPU直接100%——池化后GC次数减少90%，CPU降到20%；
CoreCLR底层动作：SocketAsyncEventArgs对应操作系统的IOCP/epoll事件，复用对象避免频繁创建销毁操作系统资源。 -
异步接受连接
csharp
bool willRaiseEvent = _listenSocket.AcceptAsync(acceptArgs);
CoreCLR底层动作：
Windows：调用AcceptEx() API，基于IOCP完成端口，异步接受连接；
Linux：调用epoll_ctl()把Socket加入epoll队列，等待连接事件；
拓展知识：AcceptAsync()是异步非阻塞的，1个线程就能处理10万连接，这就是CoreCLR高性能的核心！ -
异步接收数据
csharp
bool willRaiseReceiveEvent = e.AcceptSocket.ReceiveAsync(receiveArgs);
CoreCLR底层动作：
Windows：调用WSARecv() API，基于IOCP异步接收数据；
Linux：调用epoll_ctl()把Socket加入epoll队列，等待数据事件；
拓展知识：ReceiveAsync()完成后会触发Completed事件，CoreCLR会从线程池取一个线程处理，不会阻塞主线程。 -
发送数据
csharp
clientSocket.Send(responseBuffer);
CoreCLR底层动作：
Windows：调用WSASend() API；
Linux：调用send()系统调用；
拓展知识：高并发场景建议用SendAsync()，和ReceiveAsync()一样是异步非阻塞的，不会卡线程。
四、CoreCLR跨平台网络实现：Windows用IOCP，Linux用epoll -
Windows平台：IOCP是“性能之王”
IOCP（完成端口）：Windows操作系统提供的异步IO机制，CoreCLR的SocketAsyncEventArgs底层用IOCP实现；
优势：用少量线程处理大量IO请求——比如1个线程就能处理10万连接，因为IO完成后操作系统会通知线程，不用线程一直等；
拓展知识：CoreCLR的IOCP实现比Framework更高效，减少了线程切换的开销，现在跑10万连接CPU才用20%。 -
Linux平台：epoll是“高并发神器”
epoll：Linux内核提供的异步IO机制，CoreCLR的SocketAsyncEventArgs底层用epoll实现；
优势：比select/poll性能高100倍，支持10万+并发连接，没有文件描述符限制；
拓展知识：CoreCLR在Linux下用libuv库封装epoll，简化了跨平台的网络实现，现在.NET在Linux上跑网络服务比Java还快。 -
macOS平台：kqueue是“苹果的异步IO”
kqueue：macOS和BSD系统提供的异步IO机制，CoreCLR的SocketAsyncEventArgs底层用kqueue实现；
优势：和epoll类似，支持高并发，性能出色，适合开发跨平台的Mac应用。
五、生产级优化技巧：让你的.NET网络性能翻倍 -
复用HttpClient实例（避免端口耗尽）
csharp
// 错误示范：每次请求都new HttpClient，会导致端口耗尽
using (var client = new HttpClient())
{
var response = await client.GetAsync("https://api.example.com");
}
// 正确示范：单例复用HttpClient
private static readonly HttpClient _httpClient = new HttpClient();
public async Task<string> GetDataAsync()
{
var response = await _httpClient.GetAsync("https://api.example.com");
return await response.Content.ReadAsStringAsync();
}
我踩过的坑：之前这么写，上线1小时就炸了，现在用单例跑了半年都没出问题。
2. 用IHttpClientFactory管理HttpClient（.NET Core 2.1+推荐）
csharp
// 在Program.cs注册
builder.Services.AddHttpClient();
// 在控制器里注入
private readonly IHttpClientFactory _httpClientFactory;
public MyController(IHttpClientFactory httpClientFactory)
{
_httpClientFactory = httpClientFactory;
}
public async Task<string> GetDataAsync()
{
var client = _httpClientFactory.CreateClient();
var response = await client.GetAsync("https://api.example.com");
return await response.Content.ReadAsStringAsync();
}
优势：自动管理HttpClient的生命周期，处理DNS刷新、连接池清理等问题，比手动单例更安全。
3. 禁用Nagle算法（实时通信场景）
csharp
socket.NoDelay = true;
作用：Nagle算法会把小的TCP段合并成大的段发送，减少网络包数量，但会增加延迟——实时通信（聊天、游戏）要禁用，大文件传输可以开启。
4. 调整Socket缓冲区大小
csharp
socket.ReceiveBufferSize = 8192; // 接收缓冲区8KB
socket.SendBufferSize = 8192; // 发送缓冲区8KB
拓展知识：根据业务场景调整——大文件传输设为64KB，实时通信设为4KB，不要设太大，会浪费内存。
5. 用Span
csharp
// 用Span
Span
int bytesRead = socket.Receive(buffer);
string message = Encoding.UTF8.GetString(buffer.Slice(0, bytesRead));
优势：Span
六、总结与选型建议
-
总结
System.Net：.NET给你准备的“网络工具箱”，封装了底层复杂操作，开箱即用；
CoreCLR：.NET运行时的“翻译官”，跨平台适配Windows的IOCP和Linux的epoll，性能拉满；
性能优化核心：复用对象（HttpClient、SocketAsyncEventArgs）、减少GC、禁用Nagle算法、调整缓冲区大小；
跨平台注意：CoreCLR的网络实现已经很成熟，代码不用改就能跑在Windows、Linux、macOS上，但要注意操作系统的差异（比如Linux的文件描述符限制）。 - 选型建议
| 场景 | 推荐技术栈 | |
|---|---|---|
| 高性能TCP服务器 | SocketAsyncEventArgs（CoreCLR底层用IOCP/epoll，性能最高） | |
| 简单TCP服务器 | TcpListener（封装了Socket，简单易实现） | |
| HTTP客户端 | IHttpClientFactory（自动管理生命周期，安全可靠） | |
| 实时通信 | SignalR（封装了WebSocket、Long Polling，跨平台） | |
| 大文件传输 | Socket.SendFile()（零拷贝，性能最高） |
下一节我们会学习“网络性能调优与故障排查”，结合Wireshark抓包、性能监控工具，教你快速定位网络延迟、丢包、粘包等问题！
转载请注明出处：https://www.xin3721.com/ArticlecSharp/c49587.html
最新更新
C#网络编程之网络调试工具（Wireshark、t
C#网络编程之.NET网络实现（CoreCLR、Syste
c#网络编程之 .NET网络实现（CoreCLR、Syst
C#网络编程之操作系统网络栈（Socket、T
实战项目3：实时聊天系统
实战项目2：RESTful API服务器
实战项目1：高性能TCP服务器
C#网络编程之 IoT数据处理（边缘计算、流
C#网络编程之IoT平台开发（Azure IoT Hub、
C#网络编程之IoT设备通信（串口、蓝牙、
SQL SERVER中递归
2个场景实例讲解GaussDB(DWS)基表统计信息估
常用的 SQL Server 关键字及其含义
动手分析SQL Server中的事务中使用的锁
openGauss内核分析：SQL by pass & 经典执行
一招教你如何高效批量导入与更新数据
天天写SQL，这些神奇的特性你知道吗？
openGauss内核分析：执行计划生成
[IM002]Navicat ODBC驱动器管理器 未发现数据
初入Sql Server 之 存储过程的简单使用
uniapp/H5 获取手机桌面壁纸 (静态壁纸）
[前端] DNS解析与优化
为什么在js中需要添加addEventListener（）？
JS模块化系统
js通过Object.defineProperty() 定义和控制对象
这是目前我见过最好的跨域解决方案！
减少回流与重绘
减少回流与重绘
如何使用KrpanoToolJS在浏览器切图
performance.now() 与 Date.now() 对比