Was ist der Hauptunterschied zwischen dem Zurückgeben einer Aufgabe durch das await-Schlüsselwort und dem Zurückgeben ohne awaise-Schlüsselwort?

Question

Ich wickle AspNet.Identity. Aber etwas verwirrt mich über TPL.

Erstes Beispiel:

public virtual async Task<IdentityResult> RemovePasswordAsync(string userId) 
    { 
     var user = _store.FindByIdAsync(userId).Result; 
     if (user == null) 
      throw new InstanceNotFoundException("user"); 

     user.PasswordHash = String.Empty; 
     user.SecurityStamp = String.Empty; 
     return await UpdateAsync(user); 
    } 

    public virtual async Task<IdentityResult> UpdateAsync(TUser user) 
    { 
     await _store.UpdateAsync(user); 
     return new IdentityResult(); 
    } 

Zweites Beispiel:

public virtual Task<IdentityResult> RemovePasswordAsync(string userId) 
    { 
     var user = _store.FindByIdAsync(userId).Result; 
     if (user == null) 
      throw new InstanceNotFoundException("user"); 

     user.PasswordHash = String.Empty; 
     user.SecurityStamp = String.Empty; 
     return UpdateAsync(user); 
    } 

    public virtual async Task<IdentityResult> UpdateAsync(TUser user) 
    { 
     await _store.UpdateAsync(user); 
     return new IdentityResult(); 
    } 

Und Client nennen dies wie:

result = await _userManager.RemovePasswordAsync(user.Id); 

Meine erste Frage ist:

Wenn der Client ruft die zweite an Methode wird die Arbeit aus dem IO-Thread in einen Threadpool-Thread ausgelagert. Und wenn RemovePasswordAsync aufgerufen wird, ruft es UpdateAsync auf, das ein Warte-Schlüsselwort hat. An diesem Punkt wird dieser Threadpool-Thread in einen anderen Threadpool-Thread ausgelagert. Oder verwendet TPL stattdessen den gleichen Thread?

Und meine zweite Frage ist; Was ist der Hauptunterschied zwischen der ersten Implementierung und der zweiten Implementierung der Konstruktion dieser asynchronen Methode?

EDIT:

Dies ist die Update-Methode der Klasse Users. (_store.UpdateAsync (Benutzer))

public Task UpdateAsync(TUser user) 
    { 
     if (user == null) 
      throw new ArgumentNullException("user"); 

     return _userService.UpdateAsync(user); 
    } 

Und das ist die Update-Methode der Klasse Userservice

public Task UpdateAsync(TUser user) 
    { 
     return Task.Factory.StartNew(() => Update(user)); 
    } 

Answer 1

Ich werde Ihre erste Frage beantworten.

Sie missverstehen, wie async/abwarten funktioniert.

Eine async Methode wird synchron mindestens laufen, bis er die erste await Aussage trifft. Wenn es ein await trifft, hat es zwei Möglichkeiten:

• Wenn die awaitable (z Task) bereits abgeschlossen ist, führt die Ausführung auf dem aktuellen Kontext (das heißt UI-Thread oder Kontext der ASP.NET-Anforderung).
• Wenn das Erwartete noch nicht abgeschlossen ist, wird der übrige Text der Methode umgebrochen und die Ausführungszeit für den aktuellen Kontext (d. H. UI-Thread) (*) festgelegt, wenn die Aufgabe abgeschlossen ist.

Durch diese Definition wird der gesamte Code im Kontext der gleichen ASP.NET-Anfrage ausgeführt.

_store.UpdateAsync kann jedoch einen ThreadPool-Thread hervorbringen (z. B. mithilfe von Task.Run).

Aktualisiert

Nach Ihrer Antwort aktualisiert wird Update(user) auf einem Threadpool-Thread ausgeführt werden. Alles andere wird im aktuellen Kontext ausgeführt.

---

(*) Der Rest des Körpers des Verfahrens wird auf einem Thread Thread geplant werden, laufen wenn es keinen Kontext Synchronisation ist (das heißt, Konsolenanwendung).

Answer 2

Und meine zweite Frage ist; Was ist der Hauptunterschied zwischen der ersten Implementierung und der zweiten Implementierung der Konstruktion dieser asynchronen Methode?

Ihre erste Implementierung und sollte durch Ersetzen der Blockierung _store.FindByIdAsync(userId).Result mit asynchronen await _store.FindByIdAsync(userId) verbessert werden:

public virtual async Task<IdentityResult> RemovePasswordAsync(string userId) 
{ 
    var user = await _store.FindByIdAsync(userId); 
    if (user == null) 
     throw new InstanceNotFoundException("user"); 

    user.PasswordHash = String.Empty; 
    user.SecurityStamp = String.Empty; 
    return await UpdateAsync(user); 
} 

Ohne eine solche Aktualisierung wird der Unterschied vielleicht am besten beschrieben durch Eric Lippert here. Eine besondere Sache ist how exceptions can possibly be thrown und behandelt.

Aktualisiert, um die Kommentare zu adressieren. Sie sollten nicht mit Task.Factory.StartNew oder Task.Run in ASP.NET entladen. Dies ist nicht eine UI-App, wo Sie die Benutzeroberfläche reagieren müssen. All dies fügt nur einen Overhead eines Thread-Schalters hinzu. Der HTTP-Request-Handler, der Task.Run aufruft, dann erwartet oder blockiert mindestens die gleiche Anzahl von Threads, die Sie ausführen müssen, Sie werden die Skalierbarkeit nicht verbessern und nur die Leistung beeinträchtigen. Auf der anderen Seite macht es Sinn, natürlich IO-gebundene Aufgaben zu verwenden, die keinen Thread während der Ausführung verwenden.