Perché dovresti mai "aspettare" un metodo e quindi interrogare immediatamente il suo valore di ritorno?

In questo articolo MSDN , viene fornito il seguente codice di esempio (leggermente modificato per brevità):

public async Task<ActionResult> Details(int? id)
{
    if (id == null)
    {
        return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
    }

    Department department = await db.Departments.FindAsync(id);

    if (department == null)
    {
        return HttpNotFound();
    }

    return View(department);
}

Il FindAsyncmetodo recupera un Departmentoggetto in base al suo ID e restituisce a Task<Department>. Quindi il dipartimento viene immediatamente controllato per vedere se è nullo. A quanto ho capito, chiedere il valore dell'attività in questo modo bloccherà l'esecuzione del codice fino a quando non verrà restituito il valore dal metodo atteso, rendendolo effettivamente una chiamata sincrona.

Perché mai lo faresti? Non sarebbe più semplice chiamare il metodo sincrono Find(id), se hai intenzione di bloccare immediatamente comunque?

A quanto ho capito, chiedere il valore dell'attività in questo modo bloccherà l'esecuzione del codice fino a quando non verrà restituito il valore dal metodo atteso, rendendolo effettivamente una chiamata sincrona.

Non proprio.

Quando si chiama await db.Departments.FindAsync(id)l'attività viene inviata e il thread corrente viene restituito al pool per essere utilizzato da altre operazioni. Il flusso di esecuzione è bloccato (come sarebbe indipendentemente dall'utilizzo departmentsubito dopo, se capisco le cose correttamente), ma il thread stesso è libero di essere utilizzato da altre cose mentre aspetti che l'operazione venga completata off-machine (e segnalato da un evento o da una porta di completamento).

Se hai chiamato, d.Departments.Find(id)il thread si trova lì e aspetta la risposta, anche se la maggior parte dell'elaborazione viene eseguita sul DB.

Stai effettivamente liberando risorse CPU quando associato al disco.

Odio davvero che nessuno degli esempi mostri come sia possibile attendere alcune righe prima di attendere l'attività. Considera questo.

Foo foo = await getFoo();
Bar bar = await getBar();

Console.WriteLine(“Do some other stuff to prepare.”);

doStuff(foo, bar);

Questo è il tipo di codice incoraggiato dagli esempi e hai ragione. C'è poco senso in questo. Libera il thread principale per fare altre cose, come rispondere all'input dell'interfaccia utente, ma il vero potere di asincronizzazione / attesa è che posso facilmente continuare a fare altre cose mentre sto aspettando il completamento di un'attività potenzialmente lunga. Il codice sopra "bloccherà" e attenderà di eseguire la linea di stampa fino a quando non avremo ottenuto Foo & Bar. Non c'è bisogno di aspettare però. Possiamo elaborarlo mentre aspettiamo.

Task<Foo> foo = getFoo();
Task<Bar> bar = getBar();

Console.WriteLine(“Do some other stuff to prepare.”);

doStuff(await foo, await bar);

Ora, con il codice riscritto, non ci fermiamo e aspettiamo i nostri valori fino a quando non è necessario. Sono sempre alla ricerca di questo tipo di opportunità. Essere intelligenti quando aspettiamo può portare a significativi miglioramenti delle prestazioni. Al giorno d'oggi abbiamo più core, potremmo anche usarli.

Quindi c'è altro che succede dietro le quinte qui. Async / Await è lo zucchero sintattico. Guarda prima la firma della funzione FindAsync. Restituisce un'attività. Stai già vedendo la magia della parola chiave, scompatta quell'attività in un dipartimento.

La funzione di chiamata non si blocca. Quello che succede è che l'assegnazione al dipartimento e tutto ciò che segue la parola chiave wait viene racchiuso in una chiusura e per tutti gli effetti passati al metodo Task.ContinueWith (la funzione FindAsync viene eseguita automaticamente su un thread diverso).

Naturalmente ci sono altre cose che accadono dietro le quinte perché l'operazione viene ricondotta al thread originale (quindi non devi più preoccuparti di sincronizzarti con l'IU quando esegui un'operazione in background) e nel caso in cui la funzione chiamante sia Async ( e viene chiamato in modo asincrono) la stessa cosa accade nello stack.

Quindi quello che succede è che ottieni la magia delle operazioni di Async, senza le insidie.

No, non torna immediatamente. L'attesa rende la chiamata del metodo asincrona. Quando viene chiamato FindAsync, il metodo Dettagli ritorna con un'attività che non è terminata. Al termine, FindAsync restituirà il risultato nella variabile di reparto e riprenderà il resto del metodo Dettagli.

Mi piace pensare "asincrono" come un contratto, un contratto che dice "posso eseguirlo in modo asincrono se ne hai bisogno, ma puoi chiamarmi come qualsiasi altra funzione sincrona".

Significa che uno sviluppatore stava prendendo delle funzioni e alcune decisioni di progettazione li hanno portati a prendere / contrassegnare un gruppo di funzioni come "asincrone". Il chiamante / consumatore delle funzioni è libero di usarle come decidono. Come dici tu puoi chiamare wait attendi prima della chiamata di funzione e attendere, in questo modo l'hai trattata come una funzione sincrona, ma se lo desideri, puoi chiamarla senza attendere come

Task<Department> deptTask = db.Departments.FindAsync(id);

e dopo, diciamo, 10 linee verso il basso della funzione chiamata

Department d = await deptTask;

quindi trattandolo come una funzione asincrona.

Tocca a voi.

"se hai intenzione di bloccare immediatamente comunque" la risposta è "Sì". Solo quando hai bisogno di una risposta veloce, wait / async ha senso. Ad esempio, il thread dell'interfaccia utente arriva a un metodo davvero asincrono, il thread dell'interfaccia utente tornerà e continuerà ad ascoltare il clic del pulsante, mentre il codice sotto "wait" verrà escluso da altri thread e infine otterrà il risultato.