消防与异步忘记

Question

考虑以下代码：

public async Task<Status> SendMessage(Message message) 
{ 
    List<IMessage> _messageDispatchers = new List<IMessage>(); 
    try 
    { 
     Object[] args = new Object[] { _message }; 
     IMessage endpoint = (IMessage)Activator.CreateInstance(Type.GetType(_message.AgentDLLName), args); 
     _messageDispatchers.Add(endpoint); 

     foreach (IMessage dispatcher in _messageDispatchers) 
     { 
      await Task.Run(() => dispatcher.SendMessage(_message)); 
     } 
     return await Task.Run(() => Status.Success); 
    } 
    catch (Exception ex) 
    { 
     logger.Log(LoggerLevel.Error, ex.Message); 
     return Status.EmailSendingFailed; 
    } 

} 

的SendMessage函数：

public async Task<Status> SendMessage(OutboundMessage outboundmessage) 
{ 
    string strMessage = string.Empty; 
    string subject = string.Empty; 
    MessageServices objService = new MessageServices(); 
    try 
    { 
     var config = (from SmtpConfigurationElement ms in AppConfiguration.Instance.Smtps 
         where ms.Key == "smtp" 
         select ms).Single(); 

     SmtpClient smtpClient = new SmtpClient(config.Host); 
     smtpClient.Port = Convert.ToInt32(config.port); 
     smtpClient.EnableSsl = true; 
     smtpClient.Credentials = new NetworkCredential(config.UserName, config.Password); 

     string[] strToList = outboundmessage.ToList.Split(';'); 
     MailMessage mail = new MailMessage(); 
     mail.From = new MailAddress(outboundmessage.FromAddress); 

     if (strToList.Length > 0) 
     { 
      for (int j = 0; j < strToList.Length; j++) 
      { 
       mail.To.Add(strToList[j]); 
      } 
     } 
     else 
     { 
      _LOGGER.Log(LoggerLevel.Information, "SMTP Mail Send failed as ToList is not correct"); 
      return Status.Failed; 
     } 

     if (!string.IsNullOrEmpty(outboundmessage.CCList)) 
     { 
      string[] strCCList = outboundmessage.CCList.Split(';'); 
      if (strCCList.Length > 0) 
      { 
       for (int k = 0; k < strCCList.Length; k++) 
       { 
        mail.CC.Add(strToList[k]); 
       } 
      } 
     } 

     if (!string.IsNullOrEmpty(outboundmessage.Attachments)) 
     { 
      System.Net.Mail.Attachment attachment; 
      attachment = new System.Net.Mail.Attachment(outboundmessage.Attachments); 
      mail.Attachments.Add(attachment); 
     } 

     strMessage = await objService.ReplaceMessageWithPlaceholders(outboundmessage.PlaceholderValues, outboundmessage.MessageBody); 
     subject = await objService.ReplaceMessageWithPlaceholders(outboundmessage.PlaceholderValues, outboundmessage.Subject); 
     mail.Body = strMessage; 
     mail.Subject = subject; 
     mail.IsBodyHtml = true; 
     await Task.Run(() => smtpClient.Send(mail)); 


     return Status.Success; 
    } 
    catch (Exception ex) 
    { 
     return Status.Failed; 
    } 
} 

并调用SendMessage函数：

public Status MarketingEmail(OutboundMessage _message) 
{ 
    try 
    { 
     _message.MessageCreatedDate = System.DateTime.Now; 
     processor.SendMessage(_message); 
     return Status.Success; 
    } 
    catch (Exception ex) 
    { 
     _LOGGER.Log(LoggerLevel.Error, "Error in Marketing Email" + ex.ToString()); 
     return Status.InsertFailed; 
    } 
} 

整个想法是做一个工作流程其中发送电子邮件是最后一项任务，这应该是一个失火和遗忘的事情。

现在调用processor.SendMessage（_message）具有这样的建议：

由于此呼叫不被期待已久的，在完成该呼叫之前，在当前的方法 的继续执行。考虑将“await” 运算符应用于调用的结果。

这是一个有效的事情，因为异步&等待需要一起使用。

问题：

1. 将没有任何麻烦的现行办法的工作，如果该建议被忽略？ （我在开发阶段问这个，因为这仍然是我现在可以建议的设计变更，而不是后来遇到任何严重问题。）
2. 什么是设计工作流中的建议的最佳实践时应考虑到上述要求？

Answer 1

目前的方法将“继续工作”，因为它将继续到return Status.Success;而不用等待processor.SendMessage(_message);的呼叫完成。

然而，由于电话被解雇&遗忘，那SendMessage过载不会做的catch块中的任何记录，您运行电子邮件不能被发送的风险，但没有人收到通知了。

异步电子邮件发送的一种常用方法是：将电子邮件存储在其他地方（通常是消息队列或数据库），然后设置一个单独的异步进程来读取排队的电子邮件并发送它们。如果成功，它会将电子邮件标记为已发送。如果失败，再次尝试（达到一定的时间限制或重试＃），然后如果它放弃，它可以触发一个通知或设置以后可检查的标志。

那么你的代码将基本上可说：“没关系，电子邮件已成功排队”，而不是“没关系，电子邮件发送”。将实际发送移动到单独的过程要可靠得多。