一个服务调外部接口,刚开始每秒能处理几十个请求,跑了半天之后越来越慢,最后直接连不上。重启进程立刻恢复,再过半天又开始重复。日志里没有异常,只有超时。查到最后发现,代码在每个请求里都 new 了一个 HttpClient,用完也没释放。
HttpClient 不是普通的「请求对象」,它内部管着连接池、DNS 缓存和处理器。每次 new 一个,等于每次新建一套连接体系,旧的不主动释放就等着垃圾回收。短时间大量创建,端口很快被占满,新连接建不起来,表现出来就是「越跑越慢」「连不上」。
这篇讲 C# 网络编程里最常用的两层:HttpClient 和 Socket。重点不是 API 列表,而是「为什么这样用会出事」:实例怎么复用、超时设在哪、响应为什么必须释放、连接复用和 DNS 有什么关系。示例在本机 .NET 8 控制台项目里跑过,用本机回环地址起了一个最小的服务端,输出照实贴出。
HttpClient 应该复用,不是每次 new
一个进程里通常只应该有一个长期存活的 HttpClient 实例,或者每个上游服务一个。它是线程安全的,多个请求可以同时通过同一个实例发出。它内部持有的连接池会把用完的连接留着复用,避免每次请求都重新做 TCP 握手和 TLS 握手。
下面是一个最小的本机实验:用 HttpListener 在 127.0.0.1 上起一个服务端,再用一个设了 1 秒超时的 HttpClient 访问它。一个接口正常返回,另一个故意等 2 秒,用来观察超时行为:
using System;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
var listener = new HttpListener();
listener.Prefixes.Add("http://127.0.0.1:18081/");
listener.Start();
_ = Task.Run(async () =>
{
while (true)
{
var ctx = await listener.GetContextAsync();
var path = ctx.Request.Url!.AbsolutePath;
if (path == "/slow") await Task.Delay(2000);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/plain; charset=utf-8";
await ctx.Response.OutputStream.WriteAsync(
System.Text.Encoding.UTF8.GetBytes("hello " + path));
ctx.Response.Close();
}
});
using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(1) };
var resp = await client.GetAsync("http://127.0.0.1:18081/hello");
Console.WriteLine($"status={resp.StatusCode} body={await resp.Content.ReadAsStringAsync()}");
try
{
await client.GetAsync("http://127.0.0.1:18081/slow");
}
catch (TaskCanceledException ex)
{
Console.WriteLine("timeout caught: " + ex.GetType().Name);
}
listener.Stop();
}
}
本机 dotnet run 输出:
status=OK body=hello /hello
timeout caught: TaskCanceledException
第一次请求正常拿到 200 和响应体。第二次请求的目标接口故意延迟 2 秒,客户端 1 秒就放弃,抛出 TaskCanceledException。这里要注意:超时在 .NET 里也表现为取消异常,不是专门的 TimeoutException。看到 TaskCanceledException 时,先确认是超时还是调用方主动取消,别一概而论。
如果把 HttpClient 放进循环里每次 new,连接池就失去意义。即使每个实例用完就被回收,回收时间也不可控,短时间内创建的连接和端口可能超过系统上限。正确的做法是把实例提成静态字段、单例,或者由依赖注入容器管理生命周期。
复用一个实例还有一个好处:请求之间可以共享默认头、基础地址和处理器配置。比如把 BaseAddress 设成上游域名,后面只写相对路径;把认证头设在 DefaultRequestHeaders 上,每个请求自动带上。这些配置只做一次,不用在每个调用点重复。
如果确实需要不同的配置,比如一个客户端走代理、另一个不走,可以按用途创建多个实例,每个仍然长期存活。判断标准是「配置是否相同」,不是「请求是否不同」。同一个上游、同一套配置,就应该共用一个实例。
超时、取消与请求头
HttpClient.Timeout 是整个请求的总时限,包括连接、发送、等待响应和读取响应体。它默认是 100 秒,对多数内部服务来说太长,出问题时会让调用方线程或任务挂很久。建议按上游接口的实际耗时设置一个合理值,比如 3 秒或 5 秒,不要依赖默认值。
比全局 Timeout 更灵活的是 CancellationToken。你可以给单个请求传一个带时限的令牌,也可以把外层的取消信号一路传下来:
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2));
var request = new HttpRequestMessage(HttpMethod.Get, url);
request.Headers.Add("X-Trace-Id", "abc123");
var response = await client.SendAsync(request, cts.Token);
HttpRequestMessage 适合需要自定义方法、请求头或请求体的场景。GetAsync、PostAsync 这些快捷方法内部也是发一个请求消息,只是省了手工构造。请求头分两类:内容相关的头(比如 Content-Type)放在 request.Content.Headers,其他头放在 request.Headers。放错地方不会报错,但服务端可能收不到。
需要所有请求都带的头,比如认证令牌、User-Agent,可以设在 client.DefaultRequestHeaders 上。但要小心:默认头是共享的,多线程同时修改会出问题。启动时设好之后不要再改,需要按请求变化的头就放在单个 HttpRequestMessage 里。
超时和取消要分清楚。全局 Timeout 是兜底,防止某个请求永远不返回;单个请求的 CancellationToken 是业务控制,比如用户离开页面、外层任务被取消、批量处理超时。两者可以同时存在,哪个先触发就用哪个。取消令牌要一路传到最底层,不要在中途新建一个独立的令牌,否则外层取消根本传不进去。
超时后不要假设对方一定停止了处理。客户端放弃等待,服务端可能还在算,甚至还在往一个已经断开的连接写数据。对写操作尤其要小心:超时不代表操作没执行,重试前先确认接口是否幂等。
响应必须释放,响应体不能只拿一半
HttpResponseMessage 持有连接和流资源。用完不释放,连接可能无法回到池里,时间长了同样会耗尽。用 using 包住响应,或者调用 Dispose,是最基本的习惯。
using var response = await client.GetAsync(url);
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
EnsureSuccessStatusCode 会在状态码不是 2xx 时抛异常。它省事,但会丢掉响应体里的错误详情。很多接口在 400 或 500 时返回一段 JSON 说明原因,直接抛异常就看不到。更好的做法是先判断 IsSuccessStatusCode,失败时读取响应体再决定怎么处理。
请求体也要注意编码和类型。StringContent 默认使用文本编码,JsonContent 可以按对象序列化,MultipartFormDataContent 用于上传文件。Content-Type 会由这些类型自动设置,如果不匹配服务端要求,手动设置 Content.Headers.ContentType。发送前把实际的 Content-Type 打出来看一眼,比对着文档猜快得多。
另一个坑是只读取部分响应体。比如你只调用 ReadAsStringAsync 读了前一段就离开,或者拿到流之后没有读完就丢弃,底层连接可能无法复用,甚至一直挂在那里。要么完整读取,要么显式释放响应。大文件下载更应该用流式复制,而不是把整个响应读成字符串。
ReadAsStringAsync 会一次性把整个内容读进内存。下载大文件、拉取大 JSON 时,改用 ReadAsStreamAsync 边读边处理,或者用 CopyToAsync 写到文件。内存占用会从「文件大小」降到「缓冲区大小」。连接复用、DNS 缓存与处理器
HttpClient 本身只是门面,真正干活的是 HttpMessageHandler。HttpClient 被释放时,默认会连同处理器一起释放。如果你只释放客户端、却想保留连接池,就要把处理器单独管起来,构造客户端时传入同一个处理器。
连接复用带来一个副作用:DNS 解析结果会被缓存。服务端换了 IP,客户端可能还在往旧地址发请求,直到连接池里的旧连接失效。对长时间运行的服务,这会导致「服务已经切走,客户端还在打旧机器」。解决办法是给连接池设置一个存活时间,比如几分钟,让旧连接定期退休、重新解析 DNS。具体 API 在 .NET 8 里是 SocketsHttpHandler.PooledConnectionLifetime。
把这几层分开看,很多现象就清楚了。连接池有上限,打满之后新请求要排队;DNS 有缓存,换 IP 不会立刻生效;TLS 握手有开销,复用连接能省掉这一步;响应不读完,连接可能回不到池里。排查网络问题时,先判断卡在哪一层,再去看对应的配置。操作系统怎么处理阻塞、非阻塞和 IO 多路复用,可以看 IO 模型那一篇,这里只关心 C# 怎么把请求发出去。
需要更细的控制时,可以自己创建 SocketsHttpHandler,设置连接超时、最大连接数、是否自动重定向、是否使用代理等。但大多数业务代码用默认处理器就够了,不要一上来就调一堆参数,先把实例复用和响应释放做对。
代理和证书是另外两个常见变量。公司网络里访问外部接口可能需要代理,代码没配就会一直超时;服务端换证书后,如果客户端校验证书的逻辑写死,就可能连不上。这些都属于环境相关的问题,本地能通不代表目标环境能通,部署前要分别验证。
自动重定向也值得注意。默认情况下 HttpClient 会跟随 3xx 跳转,但跳转后的请求方法、请求体、认证头可能被改变。对接需要认证的接口时,最好显式控制是否跟随,避免认证信息被带到不该去的地方。
Socket:最底层的一次收发
HttpClient 解决的是 HTTP 协议层面的事。如果你要连一个自定义协议的服务器,或者需要直接控制 TCP,就用 TcpClient 和 NetworkStream。它们是 Socket 的托管封装,读写仍然是流式的。
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
var listener = new TcpListener(IPAddress.Loopback, 18082);
listener.Start();
var server = Task.Run(async () =>
{
using var accepted = await listener.AcceptTcpClientAsync();
using var s = accepted.GetStream();
var buf = new byte[1024];
int n = await s.ReadAsync(buf);
await s.WriteAsync(Encoding.UTF8.GetBytes(
"echo:" + Encoding.UTF8.GetString(buf, 0, n)));
});
using var client = new TcpClient();
await client.ConnectAsync(IPAddress.Loopback, 18082);
using var ns = client.GetStream();
await ns.WriteAsync(Encoding.UTF8.GetBytes("ping"));
var rb = new byte[1024];
int rn = await ns.ReadAsync(rb);
Console.WriteLine(Encoding.UTF8.GetString(rb, 0, rn));
await server;
listener.Stop();
本机输出:
echo:ping
服务端接受一个连接,读一段数据,把 echo: 加上原内容写回去;客户端连接、发送 ping、读回复,得到 echo:ping。真实协议不会这么简单,但骨架是一样的:连接、读、写、关闭。
Socket 读写有几个必须知道的点。第一,Read 返回的字节数不保证等于你请求的长度,可能只读到一部分,必须循环读到需要的数据或者遇到 0。第二,Read 返回 0 表示对端已经关闭连接,不是「暂时没数据」。第三,TCP 是流,不是消息,服务端一次写出的内容,客户端可能要分几次才读完,不能假设「一次 Read 就是一条消息」。
还要处理粘包和拆包。协议设计时要么约定长度头,要么用分隔符,要么用固定长度。只靠「读一次」解析消息,在本地测试可能正常,网络一抖就出错。这是协议层的问题,不是 C# API 的问题,但用 Socket 就绕不开。
Socket 的读写默认没有超时,网络卡住时 ReadAsync 可能一直不返回。需要超时时,可以给异步方法传 CancellationToken,或者设置 TcpClient.ReceiveTimeout 之类的同步超时。两者作用的对象不同,异步代码优先用令牌。关闭连接时也要注意:直接 Dispose 可能让还在写的数据丢失,通常先关闭发送方向,等对方处理完再关闭。
同步等待异步:为什么会把线程卡死
经常能看到这样的写法:异步方法明明返回 Task,调用方却用 .Result 或 .Wait() 就地等结果。在控制台程序里,它通常只是阻塞当前线程,看起来还能跑;但在带单线程同步上下文的环境里,这种写法可能直接死锁。
// 仅用于说明死锁场景,未在本机实测
var response = client.GetAsync(url).Result;
var body = response.Content.ReadAsStringAsync().Result;
死锁的机制并不神秘:GetAsync 内部的后续代码需要回到原来的线程继续执行,而原来的线程正被 .Result 阻塞着等任务完成。任务等线程,线程等任务,两边都不让,程序就卡住了。控制台程序没有这种单线程上下文,所以不容易复现,但代码一旦搬到有上下文的环境里就会出问题。
正确做法是让异步一路到底:入口方法标 async,内部用 await,不要在中途同步等待。如果确实只能同步调用,至少用 Task.Run 把它挪到线程池,或者使用 GetAwaiter().GetResult(),但后者仍然会阻塞,只是异常传播方式不同,不能解决所有场景。最稳妥的还是全链路异步。
.Result 来「简化」异步代码。它省掉的 await 会在某个环境里加倍还回来,而且异常会被包成 AggregateException,堆栈信息也更难读。看到代码里有 .Result 或 .Wait(),先把它当成潜在的死锁点。真实项目里的现象与排查方向
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 请求越跑越慢,最后连不上 | 每次请求 new HttpClient,连接和端口没有复用 | 搜代码里的 new HttpClient,改成单例或复用实例 |
| 调用偶发超时,日志只有取消异常 | 超时设置太短,或上游确实慢,超时也表现为 TaskCanceledException | 记录请求耗时和状态码,确认是超时还是主动取消 |
| 请求卡住不返回 | 在单线程同步上下文里用 .Result 或 .Wait() 等异步结果 | 搜 .Result 和 .Wait(),改成 await 一路到底 |
| 连接数持续上涨 | HttpResponseMessage 没有释放,响应体没读完 | 检查响应是否用 using,读取是否完整 |
| 服务换 IP 后客户端仍然打旧地址 | 连接池缓存了旧连接和 DNS 结果 | 检查连接池存活时间设置,必要时重建处理器 |
| 下载大文件时内存暴涨 | 用 ReadAsStringAsync 把整个响应读进内存 | 改用流式读取,边读边写文件 |
| 自定义 TCP 协议偶发解析错乱 | 把一次 Read 当成一条消息,遇到粘包或拆包 | 检查协议有没有长度头或分隔符,读循环是否正确处理 0 |
| 请求返回 401 或 403 | 认证头没设、设置位置不对,或令牌已过期 | 打印实际发送的请求头,确认认证信息有没有带上 |
排查网络问题的顺序建议是:先看请求有没有发出去,再看有没有收到响应,最后看响应内容对不对。不要一上来就怀疑序列化或业务逻辑,很多问题其实卡在连接建立或响应读取这一步。
边界与代价
- 单例 HttpClient 也有边界:它适合访问固定的一组上游服务。如果上游地址经常变化,或者需要不同的代理、证书配置,应该按服务分组创建实例,而不是一个实例走天下。
- 超时不是越短越好:设得太短,正常但稍慢的请求会被误杀;设得太长,故障时会拖住调用方。合理值来自对上游耗时的观察,不是拍脑袋。
- 连接池不是无限的:每个处理器有最大连接数,打满之后请求会排队。高并发场景要评估这个上限,必要时按上游分组或调大配置。
- Socket 不处理协议语义:它只负责收发字节。消息边界、编码、重试、心跳都要自己设计,别指望 TcpClient 帮你解决。
- 网络错误要分类处理:连接失败、超时、服务端 5xx、客户端 4xx,这几种原因的应对方式不同。全部当同一种错误重试,可能把问题放大。
- 重试要有上限和退避:失败后立即无限重试会把上游压垮。设置次数上限,加一点间隔,并且只对幂等请求重试。
还有一个经常被忽略的点:网络调用是跨进程、跨机器的操作,失败是常态,不是异常情况。代码里必须考虑超时、重试、部分失败,而不是假设「只要发了就一定会成功」。这也是后面要讲异步和取消的原因。
当天能自己验证的练习
以下练习都在一个控制台项目里完成,改 Program.cs 后执行 dotnet run:
- 用本文的 HttpListener 例子起一个本机服务,先用一个复用的 HttpClient 连续请求 20 次,记录耗时;再把 HttpClient 放进循环里每次 new,对比总耗时和资源占用。
- 把客户端的 Timeout 改成 3 秒,服务端延迟改成 2 秒和 4 秒各测一次,确认哪种情况会抛 TaskCanceledException。
- 在请求上设置一个 2 秒的 CancellationToken,再在外部提前取消,观察异常类型和消息,区分「超时」和「主动取消」。
- 故意不释放 HttpResponseMessage,连续请求多次,观察连接数和内存变化;再改成 using,对比结果。
- 跑通本文的 TcpListener 和 TcpClient 例子,然后把服务端一次写 10 个字节、客户端只读 5 个字节,观察第二次 Read 还能不能拿到剩下的数据。
小结
三句话收一下:HttpClient 要复用,连接池和 DNS 缓存都在它背后的处理器里;超时要显式设置,取消信号要一路传到请求;响应必须释放,大响应体要流式读取。Socket 负责字节收发,消息边界和协议语义得自己处理。
网络调用只是「和外部进程说话」的一种。更多时候,C# 程序需要启动一个本地进程、读它的输出、等它结束。下一篇讲 Process:怎么重定向标准输出和错误、为什么读输出顺序不对会死锁、WaitForExit 到底等了什么,以及怎么把整棵子进程树一起杀掉。