HttpWebRequest反向代理遇提前响应引发ProtocolViolationException的解决问询

1. 优先改用HttpClient替代HttpWebRequest #

HttpClient的设计原生适配请求体未完全发送时接收响应的场景，不会强制校验ContentLength，处理429这类提前响应更顺畅。核心实现步骤：

• 配置HttpCompletionOption.ResponseHeadersRead，让客户端收到响应头后立刻返回结果，无需等待请求体发送完毕。
• 捕获响应后判断状态码，利用Retry-After头实现重试逻辑（需提前缓存客户端请求体）。

示例代码：

var httpClient = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Put, "目标服务器地址");

// 提前缓存客户端请求体（用于重试）
using var clientBodyMs = new MemoryStream();
await clientStream.CopyToAsync(clientBodyMs);
clientBodyMs.Position = 0;

var content = new StreamContent(clientBodyMs);
content.Headers.ContentLength = clientRequest.ContentLength;
// 复制客户端的请求头
foreach (var header in clientRequest.Headers)
{
    content.Headers.TryAddWithoutValidation(header.Key, header.Value);
}
request.Content = content;

// 收到响应头就返回，不等请求体发完
var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);

if (response.StatusCode == HttpStatusCode.TooManyRequests)
{
    // 处理重试逻辑
    var retryAfter = response.Headers.RetryAfter;
    if (retryAfter.Delta.HasValue)
    {
        await Task.Delay(retryAfter.Delta.Value);
        // 用缓存的请求体重试
        clientBodyMs.Position = 0;
        request.Content = new StreamContent(clientBodyMs);
        response = await httpClient.SendAsync(request);
    }
}

// 处理最终响应

2. 若必须保留HttpWebRequest #

关键调整点 #

• 共享状态标记响应已接收：在BeginGetResponse回调中设置标记，让写入请求流的循环提前终止，避免无效IO。
• 捕获异常提取响应：ProtocolViolationException触发时，服务器的响应通常已存在于WebException的Response属性中，可从中提取429状态码。
• 缓存请求体：提前将客户端请求体读取到内存，确保重试时能重新发送完整数据。

修改后的核心代码：

// 自定义共享状态类
public class ProxyState
{
    public HttpWebRequest ServerRequest { get; set; }
    public byte[] CachedRequestBody { get; set; }
    public bool ResponseReceived { get; set; }
}

// 提前缓存客户端请求体
async Task<byte[]> CacheClientBody(Stream clientStream)
{
    using var ms = new MemoryStream();
    await clientStream.CopyToAsync(ms);
    return ms.ToArray();
}

void RequestStreamCallback(IAsyncResult result)
{
    var state = (ProxyState)result.AsyncState;
    var serverStream = state.ServerRequest.EndGetRequestStream(result);
    _ = WriteRequestBodyAsync(state, serverStream);
}

async Task WriteRequestBodyAsync(ProxyState state, Stream serverStream)
{
    var buffer = new byte[4096];
    using var ms = new MemoryStream(state.CachedRequestBody);
    int bytesRead;
    while ((bytesRead = await ms.ReadAsync(buffer)) > 0 && !state.ResponseReceived)
    {
        try
        {
            await serverStream.WriteAsync(buffer, 0, bytesRead);
        }
        catch (IOException)
        {
            // 服务器已关闭连接，终止写入
            break;
        }
    }
    try { await serverStream.FlushAsync(); }
    catch { }
}

void ResponseCallback(IAsyncResult result)
{
    var state = (ProxyState)result.AsyncState;
    state.ResponseReceived = true;

    try
    {
        using var response = (HttpWebResponse)state.ServerRequest.EndGetResponse(result);
        // 处理正常响应
    }
    catch (Exception ex)
    {
        // 从异常中提取服务器响应
        var webEx = ex as WebException ?? ex.InnerException as WebException;
        if (webEx?.Response is HttpWebResponse errorResponse)
        {
            if (errorResponse.StatusCode == HttpStatusCode.TooManyRequests)
            {
                // 执行重试逻辑
                var retryRequest = (HttpWebRequest)WebRequest.Create(state.ServerRequest.RequestUri);
                retryRequest.Method = state.ServerRequest.Method;
                // 复制原请求头
                foreach (string headerName in state.ServerRequest.Headers)
                {
                    retryRequest.Headers[headerName] = state.ServerRequest.Headers[headerName];
                }
                retryRequest.ContentLength = state.CachedRequestBody.Length;

                // 重新发送请求体
                using var retryStream = await retryRequest.GetRequestStreamAsync();
                await retryStream.WriteAsync(state.CachedRequestBody);
                using var retryResponse = (HttpWebResponse)await retryRequest.GetResponseAsync();
                // 处理重试后的响应
            }
        }
    }
}

// 初始化流程
var cachedBody = await CacheClientBody(clientStream);
var proxyState = new ProxyState
{
    ServerRequest = (HttpWebRequest)WebRequest.Create("目标服务器地址"),
    CachedRequestBody = cachedBody
};
proxyState.ServerRequest.Method = clientRequest.Method;
proxyState.ServerRequest.ContentLength = cachedBody.Length;
// 复制客户端请求头...

proxyState.ServerRequest.BeginGetRequestStream(RequestStreamCallback, proxyState);
proxyState.ServerRequest.BeginGetResponse(ResponseCallback, proxyState);

核心逻辑说明 #

• HttpWebRequest抛出ProtocolViolationException是因为写入字节数与ContentLength不匹配的校验机制，但服务器实际已返回响应，可通过WebException的Response属性获取。
• 提前缓存请求体是重试的核心前提，避免客户端流被消费后无法重新获取数据。
• 共享状态标记可终止无效的写入操作，减少资源浪费。

内容的提问来源于stack exchange，提问作者TheSoundByte