Comment puis-je savoir quand HttpClient a expiré?

Pour autant que je sache, il n'y a aucun moyen de savoir que c'est spécifiquement un délai d'expiration qui s'est produit. Est-ce que je ne cherche pas au bon endroit ou est-ce que je manque quelque chose de plus grand?

string baseAddress = "http://localhost:8080/";
var client = new HttpClient() 
{ 
    BaseAddress = new Uri(baseAddress), 
    Timeout = TimeSpan.FromMilliseconds(1) 
};
try
{
    var s = client.GetAsync("").Result;
}
catch(Exception e)
{
    Console.WriteLine(e.Message);
    Console.WriteLine(e.InnerException.Message);
}

Cela renvoie:

Une ou plusieurs erreurs se sont produites.

Une tâche a été annulée.

Vous devez attendre la GetAsyncméthode. Il lancera alors un TaskCanceledExceptions'il a expiré. De plus, GetStringAsyncet GetStreamAsyncgèrent en interne le délai d'expiration, ils ne seront JAMAIS lancés.

string baseAddress = "http://localhost:8080/";
var client = new HttpClient() 
{ 
    BaseAddress = new Uri(baseAddress), 
    Timeout = TimeSpan.FromMilliseconds(1) 
};
try
{
    var s = await client.GetAsync();
}
catch(Exception e)
{
    Console.WriteLine(e.Message);
    Console.WriteLine(e.InnerException.Message);
}

Je reproduis le même problème et c'est vraiment ennuyeux. J'ai trouvé cela utile:

HttpClient - gestion des exceptions agrégées

Le bogue dans HttpClient.GetAsync doit lever WebException, pas TaskCanceledException

Du code au cas où les liens ne vont nulle part:

var c = new HttpClient();
c.Timeout = TimeSpan.FromMilliseconds(10);
var cts = new CancellationTokenSource();
try
{
    var x = await c.GetAsync("http://linqpad.net", cts.Token);  
}
catch(WebException ex)
{
    // handle web exception
}
catch(TaskCanceledException ex)
{
    if(ex.CancellationToken == cts.Token)
    {
        // a real cancellation, triggered by the caller
    }
    else
    {
        // a web request timeout (possibly other things!?)
    }
}

J'ai trouvé que le meilleur moyen de déterminer si l'appel de service a expiré est d'utiliser un jeton d'annulation et non la propriété timeout de HttpClient:

var cts = new CancellationTokenSource();
cts.CancelAfter(timeout);

Et puis gérez l'exception CancellationException pendant l'appel de service ...

catch(TaskCanceledException)
{
    if(!cts.Token.IsCancellationRequested)
    {
        // Timed Out
    }
    else
    {
        // Cancelled for some other reason
    }
}

Bien sûr, si le délai d'expiration se produit du côté du service, cela devrait pouvoir être géré par une WebException.

Depuis http://msdn.microsoft.com/en-us/library/system.net.http.httpclient.timeout.aspx

Une requête DNS (Domain Name System) peut prendre jusqu'à 15 secondes pour revenir ou expirer. Si votre demande contient un nom d'hôte qui nécessite une résolution et que vous définissez Timeout sur une valeur inférieure à 15 secondes, cela peut prendre 15 secondes ou plus avant qu'une WebException soit levée pour indiquer un délai d'expiration de votre demande .

Vous avez ensuite accès à la Statuspropriété, voir WebExceptionStatus

Fondamentalement, vous devez attraper OperationCanceledExceptionet vérifier l'état du jeton d'annulation qui a été passé à SendAsync(ou GetAsync, ou quelle que soit la HttpClientméthode que vous utilisez):

• si elle a été annulée ( IsCancellationRequestedest vrai), cela signifie que la demande a vraiment été annulée
• sinon, cela signifie que la demande a expiré

Bien sûr, ce n'est pas très pratique ... il serait préférable de recevoir un TimeoutExceptionen cas de timeout. Je propose ici une solution basée sur un gestionnaire de message HTTP personnalisé: Meilleure gestion du délai d'expiration avec HttpClient

_httpClient = new HttpClient(handler) {Timeout = TimeSpan.FromSeconds(5)};

est ce que je fais habituellement, semble fonctionner assez bien pour moi, c'est particulièrement bon lors de l'utilisation de proxies.