Wie sollte das Warten auf eine asynchrone Aufgabe und das Anzeigen einer modalen Form in der gleichen Methode behandelt werden?

Question

Ich habe eine Windows Forms-Anwendung, in der ich eine E-Mail mit SmtpClient senden. Andere Async-Operationen in der Anwendung verwenden async/await, und ich möchte beim Senden der E-Mail idealerweise konsistent sein.

Ich zeige einen modalen Dialog mit einer Abbrechen-Schaltfläche beim Senden der E-Mail und Kombination SendMailAsync mit form.ShowDialog ist, wo die Dinge schwierig werden, da der Send warten würde, und ShowDialog würde. Mein aktueller Ansatz ist wie folgt, aber es scheint chaotisch, gibt es einen besseren Ansatz dazu?

private async Task SendTestEmail() 
{ 
    // Prepare message, client, and form with cancel button 
    using (Message message = ...) 
    { 
    SmtpClient client = ... 
    CancelSendForm form = ... 

    // Have the form button cancel async sends and 
    // the client completion close the form 
    form.CancelBtn.Click += (s, a) => 
    { 
     client.SendAsyncCancel(); 
    }; 
    client.SendCompleted += (o, e) => 
    { 
     form.Close(); 
    }; 

    // Try to send the mail 
    try 
    { 
     Task task = client.SendMailAsync(message); 
     form.ShowDialog(); 
     await task; // Probably redundant 

     MessageBox.Show("Test mail sent", "Success"); 
    } 
    catch (Exception ex) 
    { 
     string text = string.Format(
      "Error sending test mail:\n{0}", 
      ex.Message); 
     MessageBox.Show(text, "Error"); 
    } 
    } 

Answer 1

Ich würde die Form.Shown Event-Handling und die E-Mail von dort zu senden. Da es asynchron abfeuern wird, müssen Sie sich nicht darum kümmern, dass die Blockierung von "" funktioniert, und Sie haben eine etwas sauberere Möglichkeit, das Schließen des Formulars und das Anzeigen der Erfolgs- oder Fehlermeldung zu synchronisieren.

form.Shown += async (s, a) => 
{ 
    try 
    { 
     await client.SendMailAsync(message); 
     form.Close(); 
     MessageBox.Show("Test mail sent", "Success"); 
    } 
    catch(Exception ex) 
    { 
     form.Close(); 
     string text = string.Format(
      "Error sending test mail:\n{0}", 
      ex.Message); 
     MessageBox.Show(text, "Error"); 
    } 
}; 

form.ShowDialog(); 

Answer 2

Eine fragwürdige Sache über Ihre bestehende SendTestEmail Implementierung ist, dass es in der Tat synchron ist, obwohl es eine Task zurückgibt. Es kommt also nur zurück, wenn die Aufgabe bereits abgeschlossen ist, weil ShowDialog synchron ist (natürlich, weil der Dialog modal ist).

Dies kann etwas irreführend sein. Zum Beispiel würde der folgende Code nicht die erwartete Art und Weise arbeiten:

var sw = new Stopwatch(); 
sw.Start(); 
var task = SendTestEmail(); 
while (!task.IsCompleted) 
{ 
    await WhenAny(Task.Delay(500), task); 
    StatusBar.Text = "Lapse, ms: " + sw.ElapsedMilliseconds; 
} 
await task; 

Es kann leicht mit Task.Yield angesprochen werden, die asynchron auf die neue (verschachtelte) modale Dialognachrichtenschleife weiterhin erlauben würden:

public static class FormExt 
{ 
    public static async Task<DialogResult> ShowDialogAsync(
     Form @this, CancellationToken token = default(CancellationToken)) 
    { 
     await Task.Yield(); 
     using (token.Register(() => @this.Close(), useSynchronizationContext: true)) 
     { 
      return @this.ShowDialog(); 
     } 
    } 
} 

Dann könnten Sie so etwas wie dieses (nicht getestet) tun:

private async Task SendTestEmail(CancellationToken token) 
{ 
    // Prepare message, client, and form with cancel button 
    using (Message message = ...) 
    { 
     SmtpClient client = ... 
     CancelSendForm form = ... 

     // Try to send the mail 
     var ctsDialog = CancellationTokenSource.CreateLinkedTokenSource(token); 
     var ctsSend = CancellationTokenSource.CreateLinkedTokenSource(token); 
     var dialogTask = form.ShowDialogAsync(ctsDialog.Token); 
     var emailTask = client.SendMailExAsync(message, ctsSend.Token); 
     var whichTask = await Task.WhenAny(emailTask, dialogTask); 
     if (whichTask == emailTask) 
     { 
      ctsDialog.Cancel(); 
     } 
     else 
     { 
      ctsSend.Cancel(); 
     } 
     await Task.WhenAll(emailTask, dialogTask); 
    } 
} 

public static class SmtpClientEx 
{ 
    public static async Task SendMailExAsync(
     SmtpClient @this, MailMessage message, 
     CancellationToken token = default(CancellationToken)) 
    { 
     using (token.Register(() => 
      @this.SendAsyncCancel(), useSynchronizationContext: false)) 
     { 
      await @this.SendMailAsync(message); 
     } 
    } 
}