Wie kann ich feststellen, wann das Zeitlimit für HttpClient abgelaufen ist?

Soweit ich das beurteilen kann, gibt es keine Möglichkeit zu wissen, dass es sich speziell um eine Zeitüberschreitung handelt. Suche ich nicht am richtigen Ort oder vermisse ich etwas Größeres?

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);
}

Dies gibt zurück:

Ein oder mehrere Fehler sind aufgetreten.

Eine Aufgabe wurde abgebrochen.

Sie müssen die GetAsyncMethode abwarten . Es wird dann ein geworfen, TaskCanceledExceptionwenn das Zeitlimit abgelaufen ist. Zusätzlich GetStringAsyncund GetStreamAsyncintern mit Timeout umgehen, damit sie NIEMALS werfen.

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);
}

Ich reproduziere das gleiche Problem und es ist wirklich ärgerlich. Ich habe diese nützlich gefunden:

HttpClient - Umgang mit aggregierten Ausnahmen

Ein Fehler in HttpClient.GetAsync sollte eine WebException auslösen, keine TaskCanceledException

Etwas Code für den Fall, dass die Links nirgendwo hingehen:

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!?)
    }
}

Ich habe festgestellt, dass der beste Weg, um festzustellen, ob das Zeitlimit für den Serviceabruf abgelaufen ist, die Verwendung eines Stornierungs-Tokens und nicht der Timeout-Eigenschaft des HttpClient ist:

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

Und dann die CancellationException während des Serviceabrufs behandeln ...

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

Wenn das Timeout auf der Serviceseite auftritt, sollte dies natürlich von einer WebException verarbeitet werden können.

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

Es kann bis zu 15 Sekunden dauern, bis eine DNS-Abfrage (Domain Name System) zurückgegeben wird oder eine Zeitüberschreitung auftritt. Wenn Ihre Anfrage einen Hostnamen enthält, für den eine Auflösung erforderlich ist, und Sie Timeout auf einen Wert von weniger als 15 Sekunden festlegen , kann es 15 Sekunden oder länger dauern, bis eine WebException ausgelöst wird, um ein Timeout für Ihre Anfrage anzuzeigen .

Sie erhalten dann Zugriff auf die StatusEigenschaft, siehe WebExceptionStatus

Grundsätzlich müssen Sie die fangen OperationCanceledExceptionund prüfen Sie den Zustand des Widerrufs Token dass weitergegeben wurde SendAsync(oder GetAsync, oder was auch immer HttpClientMethode Sie verwenden):

• wenn es abgesagt wurde (IsCancellationRequested ist wahr), bedeutet dies, dass die Anfrage wirklich storniert wurde
• Wenn nicht, bedeutet dies, dass die Anforderung abgelaufen ist

Natürlich ist dies nicht sehr praktisch ... es wäre besser, TimeoutExceptionim Falle einer Zeitüberschreitung eine zu erhalten . Ich schlage hier eine Lösung vor, die auf einem benutzerdefinierten HTTP-Nachrichtenhandler basiert: Bessere Timeout-Behandlung mit HttpClient

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

ist das, was ich normalerweise mache, scheint ziemlich gut für mich zu funktionieren, es ist besonders gut, wenn ich Proxys benutze.