Leggere intestazioni da HttpResponseMessage prima che il contenuto sia completo al 100%

Question

1. Come accedere alle intestazioni di risposta, prima che l'intera risposta sia stata ritrasmessa?
2. Come si legge lo stream mentre arriva?
3. HttpClient è la scelta migliore per un controllo granulare della ricezione della risposta http?

Ecco un elemento di cattura che potrebbe illustrare la mia domanda:

using (var response = await _httpClient.SendAsync(request, 
    HttpCompletionOption.ResponseHeadersRead)) 
{ 
    var streamTask = response.Content.ReadAsStreamAsync(); 
    //how do I check if headers portion has completed? 
    //Does HttpCompletionOption.ResponseHeadersRead guarantee that? 
    //pseudocode 
    while (!(all headers have been received)) 
    //maybe await a Delay here to let Headers get fully populated 
    access_headers_without_causing_entire_response_to_be_received 

    //how do I access the response, without causing an await until contents downloaded? 
    //pseudocode 
    while (stremTask.Resul.?) //i.e. while something is still streaming 
    //? what goes here? a chunk-read into a buffer? or line-by-line since it's http? 
    ... 

Modifica chiarire un'altra zona grigia per me:
Ogni riferimento ho portato alla luce è una sorta di dichiarazione di blocco, ciò farebbe attendere l'arrivo dei contenuti. I riferimenti a cui leggo di solito accedono a metodi o proprietà sullo streamTask.Result o sul Contenuto e non ne so abbastanza per escludere quali riferimenti siano corretti mentre lo streamTask sta procedendo contro quali causeranno un'attesa fino a quando il compito completato.

Answer 1

Sulla base dei miei test, il contenuto non verrà trasferito fino a quando non inizierete a leggere il flusso di contenuti, e siete corretti che chiamare Task.Result sia una chiamata bloccante, ma è la sua stessa natura, è un punto di sincronizzazione. Ma, non blocca il pre-buffer dell'intero contenuto, blocca solo fino a quando il contenuto inizia in arrivo dal server.

Quindi un flusso infinito non si bloccherà per una quantità infinita di tempo. Pertanto, provare a recuperare il flusso in modo asincrono potrebbe essere considerato eccessivo, soprattutto se l'operazione di elaborazione dell'intestazione è relativamente breve. Ma se lo desideri, puoi sempre elaborare le intestazioni mentre il flusso di contenuti viene gestito su un'altra attività. Qualcosa del genere lo farebbe.

static void Main(string[] args) 
{ 
    var url = "http://somesite.com/bigdownloadfile.zip"; 
    var client = new HttpClient(); 
    var request = new HttpRequestMessage(HttpMethod.Get, url); 

    var getTask = client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead); 
    Task contentDownloadTask = null; 

    var continuation = getTask.ContinueWith((t) => 
    { 
     contentDownloadTask = Task.Run(() => 
     { 
      var resultStream = t.Result.Content.ReadAsStreamAsync().Result; 
      resultStream.CopyTo(File.Create("output.dat")); 
     }); 

     Console.WriteLine("Got {0} headers", t.Result.Headers.Count()); 
     Console.WriteLine("Blocking after fetching headers, press any key to continue..."); 
     Console.ReadKey(true); 
    }); 

    continuation.Wait(); 
    contentDownloadTask.Wait(); 
    Console.WriteLine("Finished downloading {0} bytes", new FileInfo("output.dat").Length); 

    Console.WriteLine("Finished, press any key to exit"); 
    Console.ReadKey(true); 
} 

Si noti che non c'è bisogno di controllare se la porzione di intestazioni è completo, hai esplicitamente specificato che con l'opzione HttpCompletionOption.ResponseHeadersRead. L'attività SendAsync non continuerà finché non saranno state recuperate le intestazioni.

Answer 2

Il risultato utilizzando le parole chiave attendono/asincroni è ancora più leggibile:

var url = "http://somesite.com/bigdownloadfile.zip"; 

using (var httpClient = new HttpClient()) 
using (var httpRequest = new HttpRequestMessage(HttpMethod.Get, url)) 
using(HttpResponseMessage response = await httpClient.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead)) 
using (Stream stream = await response.Content.ReadAsStreamAsync()) 
{ 
    //Access to the Stream object as it comes, buffer it or do whatever you need 
}