httphelper封装

restsharp在docker偶发接口调用慢的问题，改用原生Httpclient重写

public class HttpHelperEx : IDisposable
{
    private readonly HttpClient _httpClient;
    private readonly JsonSerializerOptions _jsonOptions;

    public HttpHelperEx(double timeout = 30)
    {
        var handler = new SocketsHttpHandler
        {
            // ✅ Docker Ubuntu 6秒问题的根因解决
            //AddressFamily = AddressFamily.InterNetwork,

            PooledConnectionLifetime = TimeSpan.FromMinutes(2),
            PooledConnectionIdleTimeout = TimeSpan.FromMinutes(1),
            MaxConnectionsPerServer = 50,

            UseProxy = false,
            ConnectTimeout = TimeSpan.FromSeconds(5),
        };

        _httpClient = new HttpClient(handler)
        {
            Timeout = TimeSpan.FromSeconds(timeout)
        };

        _jsonOptions = new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true,
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
        };
    }

    /// <summary>
    /// 异步 POST 请求
    /// </summary>
    public async Task<TResponse?> PostAsync<TResponse>(
        string url,
        object request,
        Dictionary<string, string>? headers = null,
        CancellationToken cancellationToken = default)
    {
        using var httpRequest = new HttpRequestMessage(HttpMethod.Post, url)
        {
            Content = JsonContent.Create(request, options: _jsonOptions)
        };

        AddHeaders(httpRequest, headers);

        using var response = await _httpClient.SendAsync(
            httpRequest,
            HttpCompletionOption.ResponseHeadersRead,
            cancellationToken);

        response.EnsureSuccessStatusCode();

        if (response.Content.Headers.ContentLength == 0)
            return default;

        return await response.Content.ReadFromJsonAsync<TResponse>(
            _jsonOptions,
            cancellationToken);
    }

    /// <summary>
    /// 异步 GET 请求
    /// </summary>
    public async Task<TResponse> GetAsync<TResponse>(
        string url,
        Dictionary<string, string> headers = null,
        CancellationToken cancellationToken = default)
    {
        using var httpRequest = new HttpRequestMessage(HttpMethod.Get, url);
        AddHeaders(httpRequest, headers);

        using var response = await _httpClient.SendAsync(
            httpRequest,
            HttpCompletionOption.ResponseHeadersRead,
            cancellationToken);

        response.EnsureSuccessStatusCode();

        if (response.Content.Headers.ContentLength == 0)
            return default;

        return await response.Content.ReadFromJsonAsync<TResponse>(
            _jsonOptions,
            cancellationToken);
    }

    /// <summary>
    /// 同步 POST 请求（通过异步方法实现）
    /// </summary>
    public TResponse Post<TResponse>(
        string url,
        object request,
        Dictionary<string, string> headers = null)
    {
        // 调用异步方法，使用 ConfigureAwait(false) 避免死锁风险
        return PostAsync<TResponse>(url, request, headers)
            .ConfigureAwait(false)
            .GetAwaiter()
            .GetResult();
    }

    /// <summary>
    /// 同步 GET 请求（通过异步方法实现）
    /// </summary>
    public TResponse Get<TResponse>(
        string url,
        Dictionary<string, string> headers = null)
    {
        // 调用异步方法，使用 ConfigureAwait(false) 避免死锁风险
        return GetAsync<TResponse>(url, headers)
            .ConfigureAwait(false)
            .GetAwaiter()
            .GetResult();
    }

    private static void AddHeaders(HttpRequestMessage request, Dictionary<string, string>? headers)
    {
        if (headers == null) return;

        foreach (var header in headers)
        {
            request.Headers.TryAddWithoutValidation(header.Key, header.Value);
        }
    }

    public void Dispose()
    {
    }
}