在 HttpClient 和 WebClient 之间做出决定

Question

我们的网络应用在 .Net Framework 4.0 中运行。 UI 通过 ajax 调用来调用控制器方法。

我们需要使用供应商提供的 REST 服务。我正在评估在 .Net 4.0 中调用 REST 服务的最佳方式。 REST 服务需要基本身份验证方案，并且它 可以返回 XML 和 JSON 格式的数据。不需要上传/下载大量数据，将来我也看不到任何东西。我查看了一些用于 REST 消费的开源代码项目，并没有发现任何价值来证明项目中的额外依赖是合理的。开始评估WebClient 和HttpClient。我从 NuGet 下载了 .Net 4.0 的 HttpClient。

我搜索了WebClient和HttpClient之间的区别，this site提到单个HttpClient可以处理并发调用，它可以重用解析的DNS、cookie配置和身份验证。我还没有看到我们可能因差异而获得的实际价值。

我做了一个快速的性能测试，以了解WebClient（同步调用）、HttpClient（同步和异步）的执行情况。结果如下：

对所有请求使用相同的 HttpClient 实例（最小 - 最大）

WebClient 同步：8 毫秒 - 167 毫秒
HttpClient 同步：3 毫秒 - 7228 毫秒
HttpClient 异步：985 - 10405 毫秒

为每个请求使用一个新的HttpClient（最小值 - 最大值）

WebClient 同步：4 毫秒 - 297 毫秒
HttpClient 同步：3 毫秒 - 7953 毫秒
HttpClient 异步：1027 - 10834 毫秒

代码

public class AHNData
{
    public int i;
    public string str;
}

public class Program
{
    public static HttpClient httpClient = new HttpClient();
    private static readonly string _url = "http://localhost:9000/api/values/";

    public static void Main(string[] args)
    {
       #region "Trace"
       Trace.Listeners.Clear();

       TextWriterTraceListener twtl = new TextWriterTraceListener(
           "C:\\Temp\\REST_Test.txt");
       twtl.Name = "TextLogger";
       twtl.TraceOutputOptions = TraceOptions.ThreadId | TraceOptions.DateTime;

       ConsoleTraceListener ctl = new ConsoleTraceListener(false);
       ctl.TraceOutputOptions = TraceOptions.DateTime;

       Trace.Listeners.Add(twtl);
       Trace.Listeners.Add(ctl);
       Trace.AutoFlush = true;
       #endregion

       int batchSize = 1000;

       ParallelOptions parallelOptions = new ParallelOptions();
       parallelOptions.MaxDegreeOfParallelism = batchSize;

       ServicePointManager.DefaultConnectionLimit = 1000000;

       Parallel.For(0, batchSize, parallelOptions,
           j =>
           {
               Stopwatch sw1 = Stopwatch.StartNew();
               GetDataFromHttpClientAsync<List<AHNData>>(sw1);
           });
       Parallel.For(0, batchSize, parallelOptions,
            j =>
            {
                Stopwatch sw1 = Stopwatch.StartNew();
                GetDataFromHttpClientSync<List<AHNData>>(sw1);
            });
       Parallel.For(0, batchSize, parallelOptions,
            j =>
            {
                using (WebClient client = new WebClient())
                {
                   Stopwatch sw = Stopwatch.StartNew();
                   byte[] arr = client.DownloadData(_url);
                   sw.Stop();

                   Trace.WriteLine("WebClient Sync " + sw.ElapsedMilliseconds);
                }
           });

           Console.Read();
        }

        public static T GetDataFromWebClient<T>()
        {
            using (var webClient = new WebClient())
            {
                webClient.BaseAddress = _url;
                return JsonConvert.DeserializeObject<T>(
                    webClient.DownloadString(_url));
            }
        }

        public static void GetDataFromHttpClientSync<T>(Stopwatch sw)
        {
            HttpClient httpClient = new HttpClient();
            var response = httpClient.GetAsync(_url).Result;
            var obj = JsonConvert.DeserializeObject<T>(
                response.Content.ReadAsStringAsync().Result);
            sw.Stop();

            Trace.WriteLine("HttpClient Sync " + sw.ElapsedMilliseconds);
        }

        public static void GetDataFromHttpClientAsync<T>(Stopwatch sw)
        {
           HttpClient httpClient = new HttpClient();
           var response = httpClient.GetAsync(_url).ContinueWith(
              (a) => {
                 JsonConvert.DeserializeObject<T>(
                    a.Result.Content.ReadAsStringAsync().Result);
                 sw.Stop();
                 Trace.WriteLine("HttpClient Async " + sw.ElapsedMilliseconds);
              }, TaskContinuationOptions.None);
        }
    }
}

我的问题

1. REST 调用在 3-4 秒内返回，这是可以接受的。调用 REST 服务是在控制器方法中启动的，这些方法从中调用 ajax 调用。首先，调用在不同的线程中运行，并且 不会阻止用户界面。那么，我可以坚持使用同步调用吗？
2. 上面的代码是在我的localbox中运行的。在产品设置、DNS 和代理中 将涉及查找。使用HttpClient 比使用WebClient 有什么优势吗？
3. HttpClient 的并发性是否优于 WebClient？从测试结果中，我看到WebClient 同步调用表现更好。
4. 如果我们升级到 .Net 4.5，HttpClient 会是更好的设计选择吗？性能是关键的设计因素。

Answer 1

HttpClient 是较新的 API，它具有以下优点：

• 具有良好的异步编程模型
• 由 Henrik F Nielson 工作，他基本上是 HTTP 的发明者之一，他设计的 API 让您可以轻松地遵循 HTTP 标准，例如生成符合标准的标头
• 在 .Net 框架 4.5 中，因此它对可预见的未来有一定程度的支持
• 如果您想在其他平台（.Net 4.0、Windows Phone 等）上使用该库，它还具有 xcopyable/portable-framework 版本。

如果您正在编写一个对其他 Web 服务进行 REST 调用的 Web 服务，您应该希望对所有 REST 调用使用异步编程模型，这样您就不会遇到线程不足的问题。您可能还想使用支持异步/等待的最新 C# 编译器。

注意：它不是更高性能的 AFAIK。如果你创建一个公平的测试，它的性能可能有点相似。

Answer 2

HttpClientFactory

评估创建 HttpClient 的不同方式很重要，其中一部分是理解 HttpClientFactory。

https://docs.microsoft.com/en-us/dotnet/architecture/microservices/implement-resilient-applications/use-httpclientfactory-to-implement-resilient-http-requests

我知道这不是一个直接的答案 - 但你最好从这里开始而不是在任何地方结束 new HttpClient(...)。

Answer 3

2020 年不受欢迎的观点：

对于 ASP.NET 应用程序我仍然更喜欢 WebClient 而不是 HttpClient，因为：

1. 现代实现带有基于异步/等待任务的方法
2. 内存占用更小，速度提高 2 到 5 倍（其他答案已经提到）
3. 建议“重复使用单个 应用程序生命周期内的 HttpClient 实例”。但是 ASP.NET 没有“应用程序的生命周期”，只有请求的生命周期。当前对 ASP.NET 5 的指导是使用 HttpClientFactory，但它只能通过依赖注入来使用。有些人想要一个更简单的解决方案。
4. 最重要的是，如果您像 MS 建议的那样在应用程序的整个生命周期中使用 HttpClient 的一个单例实例 - 它存在已知问题。例如 DNS 缓存问题 - HttpClient 只是忽略 TTL 并“永远”缓存 DNS。但是，有一些解决方法。如果您想了解更多关于 HttpClient 的问题和困惑，请阅读 MS github 上的this comment。

Answer 4

首先，我不是 WebClient 与 HttpClient 的权威，特别是。其次，从上面的 cmets 来看，似乎 WebClient 是 Sync ONLY 而 HttpClient 两者都是。

我做了一个快速的性能测试，以了解 WebClient（同步调用）、HttpClient（同步和异步）的执行情况。这是结果。

我认为这在考虑未来时存在巨大差异，即长时间运行的进程、响应式 GUI 等（增加了您建议的框架 4.5 的好处——根据我的实际经验，在 IIS 上速度要快得多）

Answer 5

也许您可以换一种方式来思考这个问题。 WebClient 和 HttpClient 本质上是同一事物的不同实现。我建议在整个应用程序中使用IoC Container 实现Dependency Injection pattern。您应该构造一个比低级别 HTTP 传输具有更高抽象级别的客户端接口。您可以编写同时使用WebClient 和HttpClient 的具体类，然后使用IoC 容器通过config 注入实现。

这将允许您在HttpClient 和WebClient 之间轻松切换，以便您能够在生产环境中客观地进行测试。

所以问题如下：

如果我们升级到 .Net 4.5，HttpClient 会是更好的设计选择吗？

实际上可以通过使用 IoC 容器在两个客户端实现之间切换来客观回答。这是您可能依赖的示例界面，其中不包含有关 HttpClient 或 WebClient 的任何详细信息。

/// <summary>
/// Dependency Injection abstraction for rest clients. 
/// </summary>
public interface IClient
{
    /// <summary>
    /// Adapter for serialization/deserialization of http body data
    /// </summary>
    ISerializationAdapter SerializationAdapter { get; }

    /// <summary>
    /// Sends a strongly typed request to the server and waits for a strongly typed response
    /// </summary>
    /// <typeparam name="TResponseBody">The expected type of the response body</typeparam>
    /// <typeparam name="TRequestBody">The type of the request body if specified</typeparam>
    /// <param name="request">The request that will be translated to a http request</param>
    /// <returns></returns>
    Task<Response<TResponseBody>> SendAsync<TResponseBody, TRequestBody>(Request<TRequestBody> request);

    /// <summary>
    /// Default headers to be sent with http requests
    /// </summary>
    IHeadersCollection DefaultRequestHeaders { get; }

    /// <summary>
    /// Default timeout for http requests
    /// </summary>
    TimeSpan Timeout { get; set; }

    /// <summary>
    /// Base Uri for the client. Any resources specified on requests will be relative to this.
    /// </summary>
    Uri BaseUri { get; set; }

    /// <summary>
    /// Name of the client
    /// </summary>
    string Name { get; }
}

public class Request<TRequestBody>
{
    #region Public Properties
    public IHeadersCollection Headers { get; }
    public Uri Resource { get; set; }
    public HttpRequestMethod HttpRequestMethod { get; set; }
    public TRequestBody Body { get; set; }
    public CancellationToken CancellationToken { get; set; }
    public string CustomHttpRequestMethod { get; set; }
    #endregion

    public Request(Uri resource,
        TRequestBody body,
        IHeadersCollection headers,
        HttpRequestMethod httpRequestMethod,
        IClient client,
        CancellationToken cancellationToken)
    {
        Body = body;
        Headers = headers;
        Resource = resource;
        HttpRequestMethod = httpRequestMethod;
        CancellationToken = cancellationToken;

        if (Headers == null) Headers = new RequestHeadersCollection();

        var defaultRequestHeaders = client?.DefaultRequestHeaders;
        if (defaultRequestHeaders == null) return;

        foreach (var kvp in defaultRequestHeaders)
        {
            Headers.Add(kvp);
        }
    }
}

public abstract class Response<TResponseBody> : Response
{
    #region Public Properties
    public virtual TResponseBody Body { get; }

    #endregion

    #region Constructors
    /// <summary>
    /// Only used for mocking or other inheritance
    /// </summary>
    protected Response() : base()
    {
    }

    protected Response(
    IHeadersCollection headersCollection,
    int statusCode,
    HttpRequestMethod httpRequestMethod,
    byte[] responseData,
    TResponseBody body,
    Uri requestUri
    ) : base(
        headersCollection,
        statusCode,
        httpRequestMethod,
        responseData,
        requestUri)
    {
        Body = body;
    }

    public static implicit operator TResponseBody(Response<TResponseBody> readResult)
    {
        return readResult.Body;
    }
    #endregion
}

public abstract class Response
{
    #region Fields
    private readonly byte[] _responseData;
    #endregion

    #region Public Properties
    public virtual int StatusCode { get; }
    public virtual IHeadersCollection Headers { get; }
    public virtual HttpRequestMethod HttpRequestMethod { get; }
    public abstract bool IsSuccess { get; }
    public virtual Uri RequestUri { get; }
    #endregion

    #region Constructor
    /// <summary>
    /// Only used for mocking or other inheritance
    /// </summary>
    protected Response()
    {
    }

    protected Response
    (
    IHeadersCollection headersCollection,
    int statusCode,
    HttpRequestMethod httpRequestMethod,
    byte[] responseData,
    Uri requestUri
    )
    {
        StatusCode = statusCode;
        Headers = headersCollection;
        HttpRequestMethod = httpRequestMethod;
        RequestUri = requestUri;
        _responseData = responseData;
    }
    #endregion

    #region Public Methods
    public virtual byte[] GetResponseData()
    {
        return _responseData;
    }
    #endregion
}

Full code

HttpClient Implementation

您可以使用Task.Run 使WebClient 在其实现中异步运行。

依赖注入，如果做得好，有助于缓解必须预先做出低级决策的问题。最终，知道真正答案的唯一方法是在现场环境中尝试，看看哪一个效果最好。 WebClient 很可能对某些客户更有效，而HttpClient 可能对其他客户更有效。这就是为什么抽象很重要。这意味着可以快速换入代码，或通过配置更改代码，而无需更改应用的基本设计。

顺便说一句：还有许多其他原因，您应该使用抽象而不是直接调用这些低级 API 之一。一个巨大的问题是单元可测试性。

Answer 6

我在 HttpClient、WebClient、HttpWebResponse 之间进行基准测试，然后调用 Rest Web Api

和结果 调用 Rest Web Api Benchmark

---------------------Stage 1  ---- 10 Request

{00:00:17.2232544} ====>HttpClinet
{00:00:04.3108986} ====>WebRequest
{00:00:04.5436889} ====>WebClient

---------------------Stage 1  ---- 10 Request--Small Size
{00:00:17.2232544}====>HttpClinet
{00:00:04.3108986}====>WebRequest
{00:00:04.5436889}====>WebClient

---------------------Stage 3  ---- 10 sync Request--Small Size
{00:00:15.3047502}====>HttpClinet
{00:00:03.5505249}====>WebRequest
{00:00:04.0761359}====>WebClient

---------------------Stage 4  ---- 100 sync Request--Small Size
{00:03:23.6268086}====>HttpClinet
{00:00:47.1406632}====>WebRequest
{00:01:01.2319499}====>WebClient

---------------------Stage 5  ---- 10 sync Request--Max Size

{00:00:58.1804677}====>HttpClinet    
{00:00:58.0710444}====>WebRequest    
{00:00:38.4170938}====>WebClient
    
---------------------Stage 6  ---- 10 sync Request--Max Size

{00:01:04.9964278}====>HttpClinet    
{00:00:59.1429764}====>WebRequest    
{00:00:32.0584836}====>WebClient

_____ WebClient 更快（）

var stopWatch = new Stopwatch();
        stopWatch.Start();
        for (var i = 0; i < 10; ++i)
        {
            CallGetHttpClient();
            CallPostHttpClient();
        }

        stopWatch.Stop();

        var httpClientValue = stopWatch.Elapsed;

        stopWatch = new Stopwatch();

        stopWatch.Start();
        for (var i = 0; i < 10; ++i)
        {
            CallGetWebRequest();
            CallPostWebRequest();
        }

        stopWatch.Stop();

        var webRequesttValue = stopWatch.Elapsed;


        stopWatch = new Stopwatch();

        stopWatch.Start();
        for (var i = 0; i < 10; ++i)
        {

            CallGetWebClient();
            CallPostWebClient();

        }

        stopWatch.Stop();

        var webClientValue = stopWatch.Elapsed;

//--------------函数

private void CallPostHttpClient()
    {
        var httpClient = new HttpClient();
        httpClient.BaseAddress = new Uri("https://localhost:44354/api/test/");
        var responseTask = httpClient.PostAsync("PostJson", null);
        responseTask.Wait();

        var result = responseTask.Result;
        var readTask = result.Content.ReadAsStringAsync().Result;

    }
    private void CallGetHttpClient()
    {
        var httpClient = new HttpClient();
        httpClient.BaseAddress = new Uri("https://localhost:44354/api/test/");
        var responseTask = httpClient.GetAsync("getjson");
        responseTask.Wait();

        var result = responseTask.Result;
        var readTask = result.Content.ReadAsStringAsync().Result;

    }
    private string CallGetWebRequest()
    {
        var request = (HttpWebRequest)WebRequest.Create("https://localhost:44354/api/test/getjson");

        request.Method = "GET";
        request.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip;

        var content = string.Empty;

        using (var response = (HttpWebResponse)request.GetResponse())
        {
            using (var stream = response.GetResponseStream())
            {
                using (var sr = new StreamReader(stream))
                {
                    content = sr.ReadToEnd();
                }
            }
        }

        return content;
    }
    private string CallPostWebRequest()
    {

        var apiUrl = "https://localhost:44354/api/test/PostJson";


        HttpWebRequest httpRequest = (HttpWebRequest)WebRequest.Create(new Uri(apiUrl));
        httpRequest.ContentType = "application/json";
        httpRequest.Method = "POST";
        httpRequest.ContentLength = 0;

        using (var httpResponse = (HttpWebResponse)httpRequest.GetResponse())
        {
            using (Stream stream = httpResponse.GetResponseStream())
            {
                var json = new StreamReader(stream).ReadToEnd();
                return json;
            }
        }

        return "";
    }

    private string CallGetWebClient()
    {
        string apiUrl = "https://localhost:44354/api/test/getjson";


        var client = new WebClient();

        client.Headers["Content-type"] = "application/json";

        client.Encoding = Encoding.UTF8;

        var json = client.DownloadString(apiUrl);


        return json;
    }

    private string CallPostWebClient()
    {
        string apiUrl = "https://localhost:44354/api/test/PostJson";


        var client = new WebClient();

        client.Headers["Content-type"] = "application/json";

        client.Encoding = Encoding.UTF8;

        var json = client.UploadString(apiUrl, "");


        return json;
    }