Deciding between HttpClient and WebClient

Question

Our web app is running in  Net Framework 4 0  The UI calls controller methods through ajax calls    We need to consume REST service from our vendor    I am evaluating the best way to call  REST service in  Net 4 0   The REST service requires Basic Authentication Scheme and it can return data in both XML and JSON  There is no requirement for uploading downloading huge data and I don t see anything in future  I took a look at few open source code projects for REST consumption and didn t find any value in those to justify additional dependency in the project  Started to evaluate WebClient and HttpClient  I downloaded HttpClient for  Net 4 0 from NuGet    I searched for differences between WebClient and HttpClient and this site mentioned that single HttpClient can handle concurrent calls and it can reuse resolved DNS  cookie config and authentication  I am yet to see practical values that we may gain due to the differences   I did a quick performance test to find how WebClient  sync calls   HttpClient  sync and async  perform  and here are the results   Using same HttpClient instance for all the requests  min - max      WebClient sync  8 ms - 167 ms   HttpClient sync  3 ms - 7228 ms   HttpClient async  985 - 10405 ms   Using a new HttpClient for each request  min - max      WebClient sync  4 ms - 297 ms   HttpClient sync  3 ms - 7953 ms   HttpClient async  1027 - 10834 ms   Code  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   gt                              Stopwatch sw1   Stopwatch StartNew                   GetDataFromHttpClientAsync lt List lt AHNData gt  gt  sw1                         Parallel For 0  batchSize  parallelOptions              j   gt                                Stopwatch sw1   Stopwatch StartNew                    GetDataFromHttpClientSync lt List lt AHNData gt  gt  sw1                          Parallel For 0  batchSize  parallelOptions              j   gt                                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 lt T gt                          using  var webClient   new WebClient                                  webClient BaseAddress    url                  return JsonConvert DeserializeObject lt T gt                       webClient DownloadString  url                                     public static void GetDataFromHttpClientSync lt T gt  Stopwatch sw                        HttpClient httpClient   new HttpClient                var response   httpClient GetAsync  url  Result              var obj   JsonConvert DeserializeObject lt T gt                   response Content ReadAsStringAsync   Result               sw Stop                 Trace WriteLine  HttpClient Sync     sw ElapsedMilliseconds                      public static void GetDataFromHttpClientAsync lt T gt  Stopwatch sw                       HttpClient httpClient   new HttpClient               var response   httpClient GetAsync  url  ContinueWith                 a    gt                     JsonConvert DeserializeObject lt T gt                       a Result Content ReadAsStringAsync   Result                    sw Stop                     Trace WriteLine  HttpClient Async     sw ElapsedMilliseconds                    TaskContinuationOptions None                       My Questions   The REST calls return in 3-4s which is acceptable   Calls to REST service are initiated in controller methods which gets invoked from ajax calls  To begin with  the calls run in a different thread and doesn t block UI  So  can I just stick with sync calls  The above code was run in my localbox  In prod setup  DNS and proxy lookup will be involved  Is there any advantage of using HttpClient over WebClient  Is HttpClient concurrency better than WebClient   From the test results  I see        WebClient sync calls perform better  Will HttpClient be a better design choice if we upgrade to  Net 4 5  Performance is the key design factor

User · Answer

HttpClientFactory  It s important to evaluate the different ways you can create an HttpClient  and part of that is understanding HttpClientFactory   https   docs microsoft com en-us dotnet architecture microservices implement-resilient-applications use-httpclientfactory-to-implement-resilient-http-requests  This is not a direct answer I know - but you re better off starting here than ending up with new HttpClient      everywhere

User · Answer

HttpClient is the newer of the APIs and it has the benefits of   has a good async programming model being worked on by Henrik F Nielson who is basically one of the inventors of HTTP  and he designed the API so it is easy for you to follow the HTTP standard  e g  generating standards-compliant headers is in the  Net framework 4 5  so it has some guaranteed level of support for the forseeable future also has the xcopyable portable-framework version of the library if you want to use it on other platforms -  Net 4 0  Windows Phone etc    If you are writing a web service which is making REST calls to other web services  you should want to be using an async programming model for all your REST calls  so that you don t hit thread starvation  You probably also want to use the newest C  compiler which has async await support   Note  It isn t more performant AFAIK  It s probably somewhat similarly performant if you create a fair test

User · Answer

Firstly  I am not an authority on WebClient vs  HttpClient  specifically   Secondly  from your comments above  it seems to suggest that WebClient is Sync ONLY whereas HttpClient is both      I did a quick performance test to find how WebClient  Sync calls   HttpClient  Sync and Async  perform  and here are the results    I see that as a huge difference when thinking for future  i e  long running processes  responsive GUI  etc   add to the benefit you suggest by framework 4 5 - which in my actual experience is hugely faster on IIS

User · Answer

Unpopular opinion from 2020  When it comes to ASP NET apps I still prefer WebClient over HttpClient because   The modern implementation comes with async awaitable task-based methods Has smaller memory footprint and 2x-5x faster  other answers already mention that  It s suggested to  quot reuse a single instance of HttpClient for the lifetime of your application quot   But ASP NET has no  quot lifetime of application quot   only lifetime of a request

User · Answer

I have benchmark between  HttpClient  WebClient  HttpWebResponse then call  Rest Web Api and result Call Rest Web Api Benchmark ---------------------Stage 1  ---- 10 Request   00 00 17 2232544       gt HttpClinet  00 00 04 3108986       gt WebRequest  00 00 04 5436889       gt WebClient  ---------------------Stage 1  ---- 10 Request--Small Size  00 00 17 2232544      gt HttpClinet  00 00 04 3108986      gt WebRequest  00 00 04 5436889      gt WebClient  ---------------------Stage 3  ---- 10 sync Request--Small Size  00 00 15 3047502      gt HttpClinet  00 00 03 5505249      gt WebRequest  00 00 04 0761359      gt WebClient  ---------------------Stage 4  ---- 100 sync Request--Small Size  00 03 23 6268086      gt HttpClinet  00 00 47 1406632      gt WebRequest  00 01 01 2319499      gt WebClient  ---------------------Stage 5  ---- 10 sync Request--Max Size   00 00 58 1804677      gt HttpClinet      00 00 58 0710444      gt WebRequest      00 00 38 4170938      gt WebClient      ---------------------Stage 6  ---- 10 sync Request--Max Size   00 01 04 9964278      gt HttpClinet      00 00 59 1429764      gt WebRequest      00 00 32 0584836      gt WebClient        WebClient Is faster    var stopWatch   new Stopwatch            stopWatch Start            for  var i   0  i  lt  10    i                        CallGetHttpClient                CallPostHttpClient                       stopWatch Stop             var httpClientValue   stopWatch Elapsed           stopWatch   new Stopwatch             stopWatch Start            for  var i   0  i  lt  10    i                        CallGetWebRequest                CallPostWebRequest                       stopWatch Stop             var webRequesttValue   stopWatch Elapsed            stopWatch   new Stopwatch             stopWatch Start            for  var i   0  i  lt  10    i                         CallGetWebClient                CallPostWebClient                        stopWatch Stop             var webClientValue   stopWatch Elapsed     -------------------------Functions private void CallPostHttpClient                 var httpClient   new HttpClient            httpClient BaseAddress   new Uri  quot https   localhost 44354 api test  quot            var responseTask   httpClient PostAsync  quot PostJson quot   null           responseTask Wait             var result   responseTask Result          var readTask   result Content ReadAsStringAsync   Result             private void CallGetHttpClient                 var httpClient   new HttpClient            httpClient BaseAddress   new Uri  quot https   localhost 44354 api test  quot            var responseTask   httpClient GetAsync  quot getjson quot            responseTask Wait             var result   responseTask Result          var readTask   result Content ReadAsStringAsync   Result             private string CallGetWebRequest                 var request    HttpWebRequest WebRequest Create  quot https   localhost 44354 api test getjson quot             request Method    quot GET quot           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    quot https   localhost 44354 api test PostJson quot             HttpWebRequest httpRequest    HttpWebRequest WebRequest Create new Uri apiUrl            httpRequest ContentType    quot application json quot           httpRequest Method    quot POST quot           httpRequest ContentLength   0           using  var httpResponse    HttpWebResponse httpRequest GetResponse                          using  Stream stream   httpResponse GetResponseStream                                  var json   new StreamReader stream  ReadToEnd                    return json                                   return  quot  quot              private string CallGetWebClient                 string apiUrl    quot https   localhost 44354 api test getjson quot             var client   new WebClient             client Headers  quot Content-type quot      quot application json quot            client Encoding   Encoding UTF8           var json   client DownloadString apiUrl             return json             private string CallPostWebClient                 string apiUrl    quot https   localhost 44354 api test PostJson quot             var client   new WebClient             client Headers  quot Content-type quot      quot application json quot            client Encoding   Encoding UTF8           var json   client UploadString apiUrl   quot  quot              return json

User · Answer

Perhaps you could think about the problem in a different way  WebClient and HttpClient are essentially different implementations of the same thing  What I recommend is implementing the Dependency Injection pattern with an IoC Container throughout your application  You should construct a client interface with a higher level of abstraction than the low level HTTP transfer  You can write concrete classes that use both WebClient and HttpClient  and then use the IoC container to inject the implementation via config  What this would allow you to do would be to switch between HttpClient and WebClient easily so that you are able to objectively test in the production environment  So questions like   Will HttpClient be a better design choice if we upgrade to  Net 4 5   Can actually be objectively answered by switching between the two client implementations using the IoC container  Here is an example interface that you might depend on that doesn t include any details about HttpClient or WebClient       lt summary gt      Dependency Injection abstraction for rest clients        lt  summary gt  public interface IClient            lt summary gt          Adapter for serialization deserialization of http body data          lt  summary gt      ISerializationAdapter SerializationAdapter   get              lt summary gt          Sends a strongly typed request to the server and waits for a strongly typed response          lt  summary gt           lt typeparam name  quot TResponseBody quot  gt The expected type of the response body lt  typeparam gt           lt typeparam name  quot TRequestBody quot  gt The type of the request body if specified lt  typeparam gt           lt param name  quot request quot  gt The request that will be translated to a http request lt  param gt           lt returns gt  lt  returns gt      Task lt Response lt TResponseBody gt  gt  SendAsync lt TResponseBody  TRequestBody gt  Request lt TRequestBody gt  request             lt summary gt          Default headers to be sent with http requests          lt  summary gt      IHeadersCollection DefaultRequestHeaders   get              lt summary gt          Default timeout for http requests          lt  summary gt      TimeSpan Timeout   get  set              lt summary gt          Base Uri for the client  Any resources specified on requests will be relative to this           lt  summary gt      Uri BaseUri   get  set              lt summary gt          Name of the client          lt  summary gt      string Name   get       public class Request lt TRequestBody gt         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 lt TResponseBody gt    Response        region Public Properties     public virtual TResponseBody Body   get          endregion       region Constructors          lt summary gt          Only used for mocking or other inheritance          lt  summary gt      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 lt TResponseBody gt  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          lt summary gt          Only used for mocking or other inheritance          lt  summary gt      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 You can use Task Run to make WebClient run asynchronously in its implementation  Dependency Injection  when done well helps alleviate the problem of having to make low level decisions upfront  Ultimately  the only way to know the true answer is try both in a live environment and see which one works the best  It s quite possible that WebClient may work better for some customers  and HttpClient may work better for others  This is why abstraction is important  It means that code can quickly be swapped in  or changed with configuration without changing the fundamental design of the app  BTW  there are numerous other reasons that you should use an abstraction instead of directly calling one of these low-level APIs  One huge one being unit-testability

[c#] Deciding between HttpClient and WebClient

HttpClientFactory

Examples related to c#

Examples related to .net

Examples related to rest

Examples related to webclient

Examples related to dotnet-httpclient