Come si deve gestire l'attesa di un'attività asincrona e mostrare una forma modale nello stesso metodo?

Question

Ho un'applicazione Windows Form in cui invio un'email tramite SmtpClient. Altre operazioni asincrone nell'applicazione utilizzano async/await, e mi piacerebbe essere coerenti in questo quando invio la posta.

Visualizzo una finestra di dialogo modale con un pulsante di annullamento quando si invia la posta e combina SendMailAsync con form.ShowDialog è dove le cose si complicano perché attendere l'invio si bloccherebbe, e quindi ShowDialog. Il mio attuale approccio è il seguente, ma sembra disordinato, c'è un approccio migliore a questo?

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

vorrei prendere in considerazione la gestione dell'evento Form.Shown e l'invio della mail da lì. Dal momento che si accenderà in modo asincrono, non è necessario preoccuparsi di "aggirare" la natura di blocco di ShowDialog e si dispone di un modo leggermente più pulito per sincronizzare la chiusura del modulo e mostrare il messaggio di esito positivo o negativo.

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

Una cosa discutibile sulla tua SendTestEmail implementazione attuale è che è in realtà sincrono, nonostante restituisce un Task. Quindi, restituisce solo quando l'attività è già completata, perché ShowDialog è sincrono (naturalmente, perché la finestra di dialogo è modale).

Questo può essere in qualche modo fuorviante. Ad esempio, il seguente codice non avrebbe funzionato il modo previsto:

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; 

può essere facilmente affrontato con Task.Yield, che permetterebbe di continuare in modo asincrono sul nuovo (nested) modale ciclo di messaggi di dialogo:

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(); 
     } 
    } 
} 

allora si potrebbe fare qualcosa di simile (non testata):

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); 
     } 
    } 
}