Como posso saber quando o HttpClient expirou?

Tanto quanto posso dizer, não há como saber que ocorreu especificamente um tempo limite. Não estou procurando o lugar certo ou estou perdendo algo maior?

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

Isso retorna:

Ocorreu um ou mais erros.

Uma tarefa foi cancelada.

Você precisa aguardar o GetAsyncmétodo. Em seguida, ele lançará um TaskCanceledExceptionse tiver atingido o tempo limite. Além disso, GetStringAsynce GetStreamAsynclida internamente com o tempo limite, para que NUNCA joguem.

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

Estou reproduzindo o mesmo problema e é realmente irritante. Eu achei estes úteis:

HttpClient - lidando com exceções agregadas

O bug no HttpClient.GetAsync deve gerar WebException, não TaskCanceledException

Algum código no caso de os links não chegarem a lugar algum:

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

Descobri que a melhor maneira de determinar se a chamada de serviço expirou é usar um token de cancelamento e não a propriedade timeout do HttpClient:

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

E então lide com o CancellationException durante a chamada de serviço ...

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

Obviamente, se o tempo limite ocorrer no lado do serviço, isso poderá ser tratado por uma WebException.

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

Uma consulta ao sistema de nomes de domínio (DNS) pode levar até 15 segundos para retornar ou atingir o tempo limite. Se sua solicitação contiver um nome de host que exija resolução e você definir o Tempo limite para um valor inferior a 15 segundos, poderá levar 15 segundos ou mais antes que uma WebException seja lançada para indicar um tempo limite na sua solicitação .

Você obtém acesso à Statuspropriedade, consulte WebExceptionStatus

Basicamente, você precisa capturar OperationCanceledExceptione verificar o estado do token de cancelamento que foi passado para SendAsync(ou GetAsync, ou qualquer outro HttpClientmétodo que esteja usando):

• se foi cancelado ( IsCancellationRequestedé verdade), significa que a solicitação foi realmente cancelada
• caso contrário, significa que o pedido expirou

Obviamente, isso não é muito conveniente ... seria melhor receber um TimeoutExceptionem caso de tempo limite. Eu proponho uma solução aqui com base em um manipulador de mensagens HTTP personalizado: Melhor controle de tempo limite com HttpClient

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

é o que eu costumo fazer, parece funcionar muito bem para mim, é especialmente bom ao usar proxies.