如何捕获.NET中HttpClient发起的POST请求体（含第三方库请求）

核心问题原因 #

你说得没错，POST请求体无法被默认的DiagnosticListener或EventListener捕获，本质是因为HttpClient发送请求时，HttpContent通常以流式方式传输（比如StreamContent、FormUrlEncodedContent等）。为了避免占用过多内存、破坏流的一次性消费特性，.NET的诊断事件默认不会主动读取并保存请求体内容。

可行的流式观测实现方案 #

既然无法直接操作第三方库的HttpClient实例，我们可以通过订阅DiagnosticListener并包装请求内容的方式，在流被消费时异步捕获请求体，完全不需要应用层代理，也能兼容HTTPS请求。具体步骤如下：

1. 创建可捕获内容的HttpContent包装类
   这个类会在原始内容的流被读取时，同步将内容复制到我们的存储介质（内存/文件）中，同时保证原始流能正常被HttpClient发送：

public class CapturingHttpContent : HttpContent
{
    private readonly HttpContent _originalContent;
    private readonly MemoryStream _capturedStream = new MemoryStream();

    public CapturingHttpContent(HttpContent originalContent)
    {
        _originalContent = originalContent;
        // 复制原始内容的头信息
        foreach (var header in _originalContent.Headers)
        {
            Headers.TryAddWithoutValidation(header.Key, header.Value);
        }
    }

    public string GetCapturedBody()
    {
        _capturedStream.Position = 0;
        using var reader = new StreamReader(_capturedStream);
        return reader.ReadToEnd();
    }

    protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context)
    {
        // 创建分流器，同时写入原始流和捕获流
        using var teeStream = new TeeStream(stream, _capturedStream);
        await _originalContent.CopyToAsync(teeStream, context);
    }

    protected override bool TryComputeLength(out long length)
    {
        length = _originalContent.Headers.ContentLength.GetValueOrDefault();
        return _originalContent.Headers.ContentLength.HasValue;
    }

    // 辅助类：实现流的分流写入
    private class TeeStream : Stream
    {
        private readonly Stream _primaryStream;
        private readonly Stream _secondaryStream;

        public TeeStream(Stream primary, Stream secondary)
        {
            _primaryStream = primary;
            _secondaryStream = secondary;
        }

        public override bool CanRead => false;
        public override bool CanSeek => false;
        public override bool CanWrite => true;
        public override long Length => throw new NotSupportedException();
        public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }

        public override void Flush()
        {
            _primaryStream.Flush();
            _secondaryStream.Flush();
        }

        public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException();
        public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
        public override void SetLength(long value) => throw new NotSupportedException();

        public override void Write(byte[] buffer, int offset, int count)
        {
            _primaryStream.Write(buffer, offset, count);
            _secondaryStream.Write(buffer, offset, count);
        }

        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            await _primaryStream.WriteAsync(buffer, offset, count, cancellationToken);
            await _secondaryStream.WriteAsync(buffer, offset, count, cancellationToken);
        }
    }
}

2. 订阅DiagnosticListener拦截请求
   通过DiagnosticListener.AllListeners订阅System.Net.Http的诊断事件，在请求启动时替换原始HttpContent为我们的包装类，后续在请求完成事件中获取捕获的内容：

public class HttpClientRequestCaptureObserver : IObserver<DiagnosticListener>
{
    public void OnCompleted() { }
    public void OnError(Exception error) { }

    public void OnNext(DiagnosticListener listener)
    {
        if (listener.Name != "System.Net.Http")
            return;

        listener.Subscribe(new HttpRequestCaptureObserver());
    }

    private class HttpRequestCaptureObserver : IObserver<KeyValuePair<string, object>>
    {
        public void OnCompleted() { }
        public void OnError(Exception error) { }

        public void OnNext(KeyValuePair<string, object> value)
        {
            switch (value.Key)
            {
                case "System.Net.Http.HttpRequestOut.Start":
                    if (value.Value is HttpRequestMessage request && request.Content != null)
                    {
                        // 替换原始内容为捕获类
                        request.Content = new CapturingHttpContent(request.Content);
                    }
                    break;
                case "System.Net.Http.HttpRequestOut":
                    if (value.Value is HttpRequestMessage requestCompleted && requestCompleted.Content is CapturingHttpContent capturedContent)
                    {
                        // 获取捕获的请求体并记录
                        var body = capturedContent.GetCapturedBody();
                        Console.WriteLine($"POST 请求体: {body}");
                        // 这里可以将body写入日志/数据库等
                    }
                    break;
            }
        }
    }
}

// 在应用启动时注册观察者
DiagnosticListener.AllListeners.Subscribe(new HttpClientRequestCaptureObserver());

注意事项 #

• 大文件流处理：如果请求体是超大文件（如GB级），直接用内存流捕获会导致内存溢出，此时可以修改CapturingHttpContent，将_capturedStream替换为文件流，或者设置内存阈值，超过阈值则只记录前N字节并标记为截断。
• 性能影响：分流写入会带来一定的性能开销，建议只在调试/日志场景启用，生产环境可通过配置开关控制。
• 兼容性：该方案兼容.NET Core 2.1+及.NET 5+，第三方库只要基于System.Net.Http.HttpClient实现，都会被拦截到。

内容的提问来源于stack exchange，提问作者nyan-cat