[C#] L'asincronia / attesa non necessaria quando l'attesa è l'ultima?


Answers

Sei vicino Significa che puoi scrivere in questo modo:

public Task ProcessAsync()
{
    // some sync code
    return SimulateWork();
}

In questo modo non "paghi" per l'overhead di contrassegnare il metodo come async ma continui a mantenere l'abilità di attendere l'intera operazione.

PS: Ecco uno studio sui comuni abusi di async-await :

  1. Fire-Forget metodi asincroni
  2. Metodi asincroni non necessari
  3. Operazioni a esecuzione prolungata con metodi asincroni
  4. Cattura inutilmente il contesto con metodi asincroni
Question

Ultimamente ho avuto a che fare con async (leggi tutti i possibili articoli inclusi gli ultimi 2 capitoli di Stephen e Jon), ma sono giunto alla conclusione e non so se è corretto al 100%. - Da qui la mia domanda.

Poiché async consente solo la presenza della parola in attesa, lascerò da parte async .

AFAIU, attendere è tutto sulla continuazione. invece di scrivere codice funzionale (continuativo), scrivere codice sincrono. (Mi piace riferirlo come codice callback'able )

Quindi, quando il compilatore è in await - divide il codice in 2 sezioni e registra la seconda parte da eseguire dopo che la prima parte è stata eseguita ( non so perché la parola callback non viene utilizzata - che è esattamente ciò che viene fatto ) . (nel frattempo lavorando - il thread è tornato a fare altre cose).

Ma guardando questo codice:

public async  Task ProcessAsync()
        {
           Task<string> workTask = SimulateWork();
           string st= await workTask;
           //do something with st
        }

 public    Task <string> SimulateWork()
        {
            return ...
        }

Quando il filo raggiunge await workTask; ha diviso il metodo in 2 sezioni. così dopo che SimulateWork è finito - la continuazione del metodo: AKA: //do something with st - viene eseguita.

tutto ok

Ma se il metodo fosse:

public async  Task ProcessAsync()
        {
           Task<string> workTask = SimulateWork();
           await workTask; //i don't care about the result , and I don't have any further commands 
        }

Qui - Non ho bisogno di continuazione, nel senso - Non ho bisogno await per dividere il metodo che significa - Non ho bisogno di async / attendo qui affatto! e comunque avrò lo stesso risultato / comportamento !

Quindi potrei farlo come:

   public void ProcessAsync()
            {
               SimulateWork();
            }

Domanda:

  • Ero al 100% corretto con la mia diagnostica?