Nouvelle Tentative De HttpClient Demandes Infructueuses

Au lieu de la mise en œuvre de fonctionnalité nouvelle tentative qui enveloppe le HttpClient, envisager la construction de la HttpClient avec un HttpMessageHandler qui effectue la logique de nouvelle tentative en interne. Par exemple:

public class RetryHandler : DelegatingHandler
{
    //Strongly consider limiting the number of retries - "retry forever" is
    //probably not the most user friendly way you could respond to "the
    //network cable got pulled out."
    private const int MaxRetries = 3;

    public RetryHandler(HttpMessageHandler innerHandler)
        : base(innerHandler)
    { }

    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request,
        CancellationToken cancellationToken)
    {
        HttpResponseMessage response = null;
        for (int i = 0; i < MaxRetries; i++)
        {
            response = await base.SendAsync(request, cancellationToken);
            if (response.IsSuccessStatusCode) {
                return response;
            }
        }

        return response;
    }
}

public class BusinessLogic
{
    public void FetchSomeThingsSynchronously()
    {
        //...

        //Consider abstracting this construction to a factory or IoC container
        using (var client = new HttpClient(new RetryHandler(new HttpClientHandler())))
        {
            myResult = client.PostAsync(yourUri, yourHttpContent).Result;
        }

        //...
    }
}

L'actuel réponses ne fonctionnent pas comme prévu dans tous les cas, en particulier dans le cas très commun de l'expiration du délai de demande (voir mon commentaire).

En outre, ils mettent en œuvre une très naïve réessayer stratégie autant de fois que vous voulez quelque chose d'un peu plus sophosticated, tels que l'intervalle exponentielle (qui est par défaut dans l'Azure Storage API Client).

Je suis tombé sur TOPAZE lors de la lecture d'un related post de blog (offre également une fausse interne de nouvelle tentative d'approche). Voici ce que j'ai trouvé:

//sample usage: var response = await RequestAsync(() => httpClient.GetAsync(url));
Task<HttpResponseMessage> RequestAsync(Func<Task<HttpResponseMessage>> requester)
{
    var retryPolicy = new RetryPolicy(transientErrorDetectionStrategy, retryStrategy);
    //you can subscribe to the RetryPolicy.Retrying event here to be notified 
    //of retry attempts (e.g. for logging purposes)
    return retryPolicy.ExecuteAsync(async () =>
    {
        HttpResponseMessage response;
        try
        {
            response = await requester().ConfigureAwait(false);
        }
        catch (TaskCanceledException e) //HttpClient throws this on timeout
        {
            //we need to convert it to a different exception
            //otherwise ExecuteAsync will think we requested cancellation
            throw new HttpRequestException("Request timed out", e);
        }
        //assuming you treat an unsuccessful status code as an error
        //otherwise just return the respone here
        return response.EnsureSuccessStatusCode(); 
    });
}

Note le requester délégué paramètre. Il devrait pas être un HttpRequestMessage puisque vous ne pouvez pas envoyer la même demande à plusieurs reprises. Comme pour les stratégies, qui dépend de votre cas d'utilisation. Par exemple, une erreur passagère stratégie de détection pourrait être aussi simple que:

private sealed class TransientErrorCatchAllStrategy : ITransientErrorDetectionStrategy
{
    public bool IsTransient(Exception ex)
    {
        return true;
    }
}

Que la nouvelle tentative de la stratégie, de la TOPAZE propose trois options:

1. FixedInterval
2. Différentiels
3. ExponentialBackoff

Par exemple, voici la TOPAZE équivalent de ce que l'Azur du Client de Stockage de la Bibliothèque utilise par défaut:

int retries = 3;
var minBackoff = TimeSpan.FromSeconds(3.0);
var maxBackoff = TimeSpan.FromSeconds(120.0);
var deltaBackoff= TimeSpan.FromSeconds(4.0);
var strategy = new ExponentialBackoff(retries, minBackoff, maxBackoff, deltaBackoff);

Pour plus d'informations, voir http://msdn.microsoft.com/en-us/library/hh680901(v=pandp.50).aspx

MODIFIER Notez que si votre requête contient un HttpContent objet, vous aurez à le régénérer à chaque fois qu'qui seront vendus par HttpClient ainsi (merci pour la capture de Alexandre Pépin). Par exemple () => httpClient.PostAsync(url, new StringContent("foo"))).

j'ai presque le même problème.
HttpWebRequest des files d'attente de la bibliothèque, qui garantit la demande de livraison
Je viens de mettre à jour (voir EDIT3) mon approche pour éviter les collisions, mais j'ai encore besoin de mécanisme général pour garantir la livraison d'un message (ou la re-livraison, dans le cas où le message n'a pas été livré).

Avec RestEase Et de la Tâche, lors de la nouvelle tentative avec httpClient réutilisés dans de nombreux appel (singleton) il frezze et de le jeter TaskCanceledException.
Pour résoudre ce blé nécessité de les Éliminer() l'échec de la réponse avant de réessayer

public class RetryHandler : DelegatingHandler
{
    //Strongly consider limiting the number of retries - "retry forever" is
    //probably not the most user friendly way you could respond to "the
    //network cable got pulled out."
    private const int MaxRetries = 3;

    public RetryHandler(HttpMessageHandler innerHandler)
        : base(innerHandler)
    { }

    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request,
        CancellationToken cancellationToken)
    {
        HttpResponseMessage response = null;
        for (int i = 0; i < MaxRetries; i++)
        {
            response = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
            if (response.IsSuccessStatusCode) {
                return response;
            }

            response.Dispose();
        }

        return response;
    }
}

Vous référer également à la Construction d'un Transitoire de Réessayer Gestionnaire pour l' .NET HttpClient.
Visite reportez-vous à KARTHIKEYAN VIJAYAKUMAR post.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.SqlClient;
using System.Net.Http;
using System.Threading;
using System.Diagnostics;
using System.Net;
using Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling;
namespace HttpClientRetyDemo
{
class Program
{
static void Main(string[] args)
{
var url = "http://RestfulUrl";
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, url);
var handler = new RetryDelegatingHandler
{
UseDefaultCredentials = true,
PreAuthenticate = true,
Proxy = null
};
HttpClient client = new HttpClient(handler);
var result = client.SendAsync(httpRequestMessage).Result.Content
.ReadAsStringAsync().Result;
Console.WriteLine(result.ToString());
Console.ReadKey();
}
}
///<summary>
///Retry Policy = Error Detection Strategy + Retry Strategy
///</summary>
public static class CustomRetryPolicy
{
public static RetryPolicy MakeHttpRetryPolicy()
{
//The transient fault application block provides three retry policies
// that you can use. These are:
return new RetryPolicy(strategy, exponentialBackoff);
}
}
///<summary>
///This class is responsible for deciding whether the response was an intermittent
///transient error or not.
///</summary>
public class HttpTransientErrorDetectionStrategy : ITransientErrorDetectionStrategy
{
public bool IsTransient(Exception ex)
{
if (ex != null)
{
HttpRequestExceptionWithStatus httpException;
if ((httpException = ex as HttpRequestExceptionWithStatus) != null)
{
if (httpException.StatusCode == HttpStatusCode.ServiceUnavailable)
{
return true;
}
else if (httpException.StatusCode == HttpStatusCode.MethodNotAllowed)
{
return true;
}
return false;
}
}
return false;
}
}
///<summary>
///The retry handler logic is implementing within a Delegating Handler. This has a
///number of advantages.
///An instance of the HttpClient can be initialized with a delegating handler making
///it super easy to add into the request pipeline.
///It also allows you to apply your own custom logic before the HttpClient sends the
///request, and after it receives the response.
///Therefore it provides a perfect mechanism to wrap requests made by the HttpClient
///with our own custom retry logic.
///</summary>
class RetryDelegatingHandler : HttpClientHandler
{
public RetryPolicy retryPolicy { get; set; }
public RetryDelegatingHandler()
: base()
{
retryPolicy = CustomRetryPolicy.MakeHttpRetryPolicy();
}
protected async override Task<HttpResponseMessage> SendAsync(
HttpRequestMessage request,
CancellationToken cancellationToken)
{
HttpResponseMessage responseMessage = null;
var currentRetryCount = 0;
//On Retry => increments the retry count
retryPolicy.Retrying += (sender, args) =>
{
currentRetryCount = args.CurrentRetryCount;
};
try
{
await retryPolicy.ExecuteAsync(async () =>
{
responseMessage = await base.SendAsync(request, cancellationToken)
.ConfigureAwait(false);
if ((int)responseMessage.StatusCode > 500)
{
//When it fails after the retries, it would throw the exception
throw new HttpRequestExceptionWithStatus(
string.Format("Response status code {0} indicates server error",
(int)responseMessage.StatusCode))
{
StatusCode = responseMessage.StatusCode,
CurrentRetryCount = currentRetryCount
};
}//returns the response to the main method(from the anonymous method)
return responseMessage;
}, cancellationToken).ConfigureAwait(false);
return responseMessage;//returns from the main method => SendAsync
}
catch (HttpRequestExceptionWithStatus exception)
{
if (exception.CurrentRetryCount >= 3)
{
//write to log
}
if (responseMessage != null)
{
return responseMessage;
}
throw;
}
catch (Exception)
{
if (responseMessage != null)
{
return responseMessage;
}
throw;
}
}
}
///<summary>
///Custom HttpRequestException to allow include additional properties on my exception,
///which can be used to help determine whether the exception is a transient
///error or not.
///</summary>
public class HttpRequestExceptionWithStatus : HttpRequestException
{
public HttpStatusCode StatusCode { get; set; }
public int CurrentRetryCount { get; set; }
public HttpRequestExceptionWithStatus()
: base() { }
public HttpRequestExceptionWithStatus(string message)
: base(message) { }
public HttpRequestExceptionWithStatus(string message, Exception inner)
: base(message, inner) { }
}
}