异步/同步实现中的 HttpClient 返回 WaitingForActivation

Question

我在 HttpClient 的异步同步实现方面遇到问题。

Id = 8, Status = WaitingForActivation, Method = "{null}", Result = "{Not yet computed}"

我知道我正在做的可能是一种不好的做法，最好让所有路径异步，但这是公司向我提出的要求，所以我必须这样做。

项目是在 NET Standard 1.1 中构建的，可用作 NuGet 包并与 Framework 和 Core 兼容。

这是我的主要客户端构造...

private static HttpClient _client;
private static Uri _baseAddress;
private static readonly JsonSerializerSettings _settings = new JsonSerializerSettings
    { DefaultValueHandling = DefaultValueHandling.Ignore, NullValueHandling = NullValueHandling.Ignore, MissingMemberHandling = MissingMemberHandling.Ignore };

public Client() { }

private Client(string baseUrl, Config config)
{
    _baseAddress = new Uri(baseUrl);

    _client = new HttpClient { Timeout = TimeSpan.FromSeconds(config.Timeout) };

    _client.DefaultRequestHeaders.Accept.Clear();
    _client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
    _client.DefaultRequestHeaders.Add("X-API-KEY", config.Token);
}

private Client _paymentClient;
private Client _mainClient;

public Client Create(bool payment, Config config = null)
{
    if (!payment)
    {
        _mainClient = _mainClient ?? new Client("https://api.address.com/", config);
        return _mainClient;
    }

    _paymentClient = _paymentClient ?? new Client("https://payment.address.com/", config);
    return _paymentClient;
}

public void Dispose() => _client.Dispose();

private static async Task<T> Send<T>(HttpMethod method, string url, object data = null)
{
    var uri = new UriBuilder(_baseAddress);
        uri.Path += url;

    var request = new HttpRequestMessage(method, uri.Uri);

    if (data != null)
        request.Content = new StringContent(JsonConvert.SerializeObject(data, _settings), Encoding.UTF8, "application/json");

    var response = await _client.SendAsync(request).ConfigureAwait(false);
    response.EnsureSuccessStatusCode();

    var content = await response.Content.ReadAsStringAsync();

    T result = default;

        if (response.IsSuccessStatusCode)
        {
            if (response.Content.Headers.ContentType.MediaType == "application/json")
            {
                var responseObj = JsonConvert.DeserializeObject<Response<T>>(content, _settings);

                if (responseObj.HasError)
                    throw new Safe2PayException(responseObj.ErrorCode, responseObj.Error);

                responseObj.ResponseDetail = result;
            }
        }
        else throw new Exception((int) response.StatusCode + "-" + response.StatusCode);

    request.Dispose();
    response.Dispose();

    return result;
}

Send<T> 方法应该是处理请求和响应的一般处理方法，包装在这样的通用调用中：

internal Task<T> Get<T>(string url) => Send<T>(HttpMethod.Get, url);

//OR even async...

internal async Task<T> Get<T>(string url) => await Send<T>(HttpMethod.Get, url);

这样调用，发送和接收数据..

private Client Client { get; }

public CheckoutRequest(Config config) => Client = new Client().Create(true, config);

public object Credit(Transaction transaction)
{
    var response = Client.Post<Transaction>("v2/Payment", transaction);
    return response;
}

我的问题是客户总是给我一个WaitingfForActivation 甚至是Running 或WaitingToRun，如果我把它改成...

Task.Run(() => Send<T>(HttpMethod.Get, url));
//or
Task.Run(() => Send<T>(HttpMethod.Get, url).Result);
//or
Task.Run(async () => await Send<T>(HttpMethod.Get, url));
//or
Task.Run(async () => await Send<T>(HttpMethod.Get, url).ConfigureAwait(false));

我一直试图找出我做错了什么，试图改变所有的等待，但我没有成功，所以非常感谢任何帮助。

Answer 1

我怀疑你的问题在这里：

public object Credit(Transaction transaction)
{
    var response = Client.Post<Transaction>("v2/Payment", transaction);
    return response;
}

您没有显示Post<T>() 的代码，但我认为它也是async Task<T> 方法，这意味着response 是Task<T>，您的代码基本上是这样做的：

1. 开始一项任务。
2. 返回未完成任务的描述。

当我认为这确实是你想要的：

1. 开始任务。
2. 等待任务完成。
3. 返回任务结果。

理想情况下，这应该是一个async 方法，您可以await 任务：

public async Task<object> Credit(Transaction transaction)
{
    var response = await Client.Post<Transaction>("v2/Payment", transaction);
    return response;
}

如果您绝对必须同步等待任务（需要这样做的理由很少），那么您可以使用.GetAwaiter().GetResult()：

public object Credit(Transaction transaction)
{
    var response = Client.Post<Transaction>("v2/Payment", transaction).GetAwaiter().GetResult();
    return response;
}

.GetAwaiter().GetResult() 而不是.Result 的主要好处是，在出现异常的情况下，它将抛出实际 异常而不是AggregateException。

另外，你可以让你的Create()方法static：

public static Client Create(bool payment, Config config = null)

那么你不需要初始化类来调用它：

public CheckoutRequest(Config config) => Client = Client.Create(true, config);

更新：如果您想要 async 和非异步版本的相同方法，您可以遵循 Microsoft 使用的相同标准，并使用 Async 后缀命名 async 方法.非异步版本只能调用异步版本。例如：

public async Task<object> CreditAsync(Transaction transaction)
{
    var response = await Client.Post<Transaction>("v2/Payment", transaction);
    return response;
}

public object Credit(Transaction transaction)
{
    return CreditAsync(transaction).GetAwaiter().GetResult();
}