Décider entre HttpClient et WebClient

notre application web tourne dans .net Framework 4.0. Les méthodes du contrôleur des appels de L'interface utilisateur via les appels ajax.

nous avons besoin de consommer le service de repos de notre vendeur. Je suis en train d'évaluer la meilleure façon d'appeler le service de repos à .Net 4.0. Le service REST nécessite un système D'authentification de base et il peut renvoyer des données à la fois en XML et en JSON. Il n'y a aucune exigence pour télécharger/télécharger d'énormes données et je ne vois rien à l'avenir. J'ai jeté un oeil à quelques code source ouvert projets pour la consommation de repos et n'a pas trouvé de valeur dans ceux pour justifier une dépendance supplémentaire dans le projet. Commencé à évaluer WebClient et HttpClient . J'ai téléchargé HttpClient pour .Net 4.0 à partir de NuGet.

j'ai cherché des différences entre WebClient et HttpClient et ce site a mentionné qu'un seul HttpClient peut traiter des appels concurrents et qu'il peut réutiliser des DNS résolus, la configuration des cookies et l'authentification. Je suis encore à voir les valeurs pratiques que nous pouvons avoir, en raison des différences.

j'ai fait un test de performance rapide pour trouver comment WebClient (Appels sync), HttpClient (sync et async) effectuer. et voici les résultats:

utilisant la même instance HttpClient pour toutes les requêtes (min-max)

WebClient sync: 8 ms - 167 ms

HttpClient sync: 3 ms-7228 ms

HttpClient async: 985-10405 ms

utilisant un nouveau HttpClient pour chaque requête (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:TempREST_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);
        }
    }
}

Mes Questions

1. Le RESTE des appels de retour dans 3-4s qui est acceptable. Les appels au REPOS le service est initié dans des méthodes de controller qui sont invoquées par les appels ajax. Pour commencer, les appels s'exécutent dans un fil différent et ne pas bloquer l'INTERFACE utilisateur. Je peux rester avec les appels sync?
2. le code ci-dessus a été exécuté dans ma boîte locale. Dans la configuration prod, DNS et proxy la recherche sera impliquée. Y a-t-il un avantage à utiliser HttpClient plutôt que WebClient ?
3. Est HttpClient la simultanéité de mieux que WebClient ? D'après les résultats des tests, je vois que les appels de synchronisation WebClient fonctionnent mieux.
4. est-ce que HttpClient sera un meilleur choix de conception si nous passons à .Net 4.5? La Performance est le facteur clé de la conception.