Obteniendo un MailMessage enviado en la "Carpeta Enviada"

Question

Estoy enviando MailMessages con un SmtpClient (que se entrega correctamente) utilizando un Exchange Server pero me gustaría que mis correos electrónicos enviados a la Carpeta Enviada de la dirección de correo electrónico que estoy enviando ellos de (no sucede).

using (var mailMessage = new MailMessage("fromaddress@blah.com", "toaddress@blah.com", "subject", "body")) 
{ 
    var smtpClient = new SmtpClient("SmtpHost") 
    { 
     EnableSsl = false, 
     DeliveryMethod = SmtpDeliveryMethod.Network 
    }; 

    // Apply credentials 
    smtpClient.Credentials = new NetworkCredential("smtpUsername", "smtpPassword"); 

    // Send 
    smtpClient.Send(mailMessage); 
} 

¿Hay una configuración que me falta que se asegurará de que todos mis mensajes de correo electrónico enviados desde "fromaddress@blah.com" llegará a su carpeta Sent?

Answer 1

Supongo que su requisito se orienta principalmente a dar a los usuarios visibilidad de los correos electrónicos que se han enviado. La carpeta de elementos enviados sería un método para permitir que esto ocurra. En el pasado, resolví este problema agregando un BCC Address que literalmente enviaba el correo electrónico directamente a una lista de distribución, usuario o buzón compartido que permitía a los usuarios revisar lo que se había enviado.

probar esto con una regla de Outlook de algún tipo para mover el elemento a sus carpeta de elementos enviados marcado como leído ...

using (var mailMessage = new MailMessage(
     "fromaddress@blah.com", 
     "toaddress@blah.com", 
     "", 
     "fromaddress@blah.com", 
     "subject", 
     "body")) 
{ 
    var smtpClient = new SmtpClient("SmtpHost") 
    { 
     EnableSsl = false, 
     DeliveryMethod = SmtpDeliveryMethod.Network 
    }; 

    // Apply credentials 
    smtpClient.Credentials = new NetworkCredential("smtpUsername", "smtpPassword"); 

    // Send 
    smtpClient.Send(mailMessage); 
} 

Answer 2

Debe enviar el mensaje desde Outlook si desea tener el mensaje enviado en la carpeta "Mensajes enviados". Esta carpeta es un concepto de Outlook (y muchos otros clientes de correo), no un concepto de SMTP.

Puede usar la API de automatización de Outlook para solicitar a Outlook que cree un correo electrónico y lo envíe.

Answer 3

yo he hecho esto, por lo que está completo aquí es cómo hacerlo correctamente. Utilizando el servicio gestionado web de intercambio (http://msdn.microsoft.com/en-us/library/dd633709%28EXCHG.80%29.aspx):

ExchangeService service = new ExchangeService(ExchangeVersion.Exchange2007_SP1); 

// In case you have a dodgy SSL certificate: 
System.Net.ServicePointManager.ServerCertificateValidationCallback = 
      delegate(Object obj, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors) 
      { 
       return true; 
      }; 

service.Credentials = new WebCredentials("username", "password", "MYDOMAIN"); 
service.Url = new Uri("https://exchangebox/EWS/Exchange.asmx"); 

EmailMessage em = new EmailMessage(service); 
em.Subject = "example email"; 
em.Body = new MessageBody("hello world"); 
em.Sender = new Microsoft.Exchange.WebServices.Data.EmailAddress("john.smith@example.com"); 
em.ToRecipients.Add(new Microsoft.Exchange.WebServices.Data.EmailAddress("bob.smith@example.com")); 

// Send the email and put it into the SentItems: 
em.SendAndSaveCopy(WellKnownFolderName.SentItems); 

Answer 4

He estado buscando una respuesta a esta pregunta, pero sin depender de un servidor de Exchange, y en lugar de utilizar un servidor IMAP. No sé si esto queda fuera del alcance de la pregunta, pero lo encontré buscando "Recibir un mensaje de correo enviado a la carpeta de envío", que fue mi problema en primer lugar.

no ha encontrado una respuesta directa en cualquier lugar que construyó mi propia solución basada en:

• Simple IMAP CLIENT en el MSDN
• Convert MailMessage to Raw text aquí en Stackoverflow, un paso necesario para guardar el mensaje.

estoy poniendo en práctica el método de guardar como una extensión de SMTPClient así, en lugar de .Send() de que va a utilizar .SendAndSaveMessageToIMAP().

public static class SmtpClientExtensions 
{ 
    static System.IO.StreamWriter sw = null; 
    static System.Net.Sockets.TcpClient tcpc = null; 
    static System.Net.Security.SslStream ssl = null; 
    static string path; 
    static int bytes = -1; 
    static byte[] buffer; 
    static System.Text.StringBuilder sb = new System.Text.StringBuilder(); 
    static byte[] dummy; 

    /// <summary> 
    /// Communication with server 
    /// </summary> 
    /// <param name="command">The command beeing sent</param> 
    private static void SendCommandAndReceiveResponse(string command) 
    { 
     try 
     { 
      if (command != "") 
      { 
       if (tcpc.Connected) 
       { 
        dummy = System.Text.Encoding.ASCII.GetBytes(command); 
        ssl.Write(dummy, 0, dummy.Length); 
       } 
       else 
       { 
        throw new System.ApplicationException("TCP CONNECTION DISCONNECTED"); 
       } 
      } 
      ssl.Flush(); 

      buffer = new byte[2048]; 
      bytes = ssl.Read(buffer, 0, 2048); 
      sb.Append(System.Text.Encoding.ASCII.GetString(buffer)); 

      sw.WriteLine(sb.ToString()); 
      sb = new System.Text.StringBuilder(); 
     } 
     catch (System.Exception ex) 
     { 
      throw new System.ApplicationException(ex.Message); 
     } 
    } 

    /// <summary> 
    /// Saving a mail message before beeing sent by the SMTP client 
    /// </summary> 
    /// <param name="self">The caller</param> 
    /// <param name="imapServer">The address of the IMAP server</param> 
    /// <param name="imapPort">The port of the IMAP server</param> 
    /// <param name="userName">The username to log on to the IMAP server</param> 
    /// <param name="password">The password to log on to the IMAP server</param> 
    /// <param name="sentFolderName">The name of the folder where the message will be saved</param> 
    /// <param name="mailMessage">The message being saved</param> 
    public static void SendAndSaveMessageToIMAP(this System.Net.Mail.SmtpClient self, System.Net.Mail.MailMessage mailMessage, string imapServer, int imapPort, string userName, string password, string sentFolderName) 
    { 
     try 
     { 
      path = System.Environment.CurrentDirectory + "\\emailresponse.txt"; 

      if (System.IO.File.Exists(path)) 
       System.IO.File.Delete(path); 

      sw = new System.IO.StreamWriter(System.IO.File.Create(path)); 

      tcpc = new System.Net.Sockets.TcpClient(imapServer, imapPort); 

      ssl = new System.Net.Security.SslStream(tcpc.GetStream()); 
      ssl.AuthenticateAsClient(imapServer); 
      SendCommandAndReceiveResponse(""); 

      SendCommandAndReceiveResponse(string.Format("$ LOGIN {1} {2} {0}", System.Environment.NewLine, userName, password)); 

      using (var m = mailMessage.RawMessage()) 
      { 
       m.Position = 0; 
       var sr = new System.IO.StreamReader(m); 
       var myStr = sr.ReadToEnd(); 
       SendCommandAndReceiveResponse(string.Format("$ APPEND {1} (\\Seen) {{{2}}}{0}", System.Environment.NewLine, sentFolderName, myStr.Length)); 
       SendCommandAndReceiveResponse(string.Format("{1}{0}", System.Environment.NewLine, myStr)); 
      } 
      SendCommandAndReceiveResponse(string.Format("$ LOGOUT{0}", System.Environment.NewLine)); 
     } 
     catch (System.Exception ex) 
     { 
      System.Diagnostics.Debug.WriteLine("error: " + ex.Message); 
     } 
     finally 
     { 
      if (sw != null) 
      { 
       sw.Close(); 
       sw.Dispose(); 
      } 
      if (ssl != null) 
      { 
       ssl.Close(); 
       ssl.Dispose(); 
      } 
      if (tcpc != null) 
      { 
       tcpc.Close(); 
      } 
     } 

     self.Send(mailMessage); 
    } 
} 
public static class MailMessageExtensions 
{ 
    private static readonly System.Reflection.BindingFlags Flags = System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic; 
    private static readonly System.Type MailWriter = typeof(System.Net.Mail.SmtpClient).Assembly.GetType("System.Net.Mail.MailWriter"); 
    private static readonly System.Reflection.ConstructorInfo MailWriterConstructor = MailWriter.GetConstructor(Flags, null, new[] { typeof(System.IO.Stream) }, null); 
    private static readonly System.Reflection.MethodInfo CloseMethod = MailWriter.GetMethod("Close", Flags); 
    private static readonly System.Reflection.MethodInfo SendMethod = typeof(System.Net.Mail.MailMessage).GetMethod("Send", Flags); 

    /// <summary> 
    /// A little hack to determine the number of parameters that we 
    /// need to pass to the SaveMethod. 
    /// </summary> 
    private static readonly bool IsRunningInDotNetFourPointFive = SendMethod.GetParameters().Length == 3; 

    /// <summary> 
    /// The raw contents of this MailMessage as a MemoryStream. 
    /// </summary> 
    /// <param name="self">The caller.</param> 
    /// <returns>A MemoryStream with the raw contents of this MailMessage.</returns> 
    public static System.IO.MemoryStream RawMessage(this System.Net.Mail.MailMessage self) 
    { 
     var result = new System.IO.MemoryStream(); 
     var mailWriter = MailWriterConstructor.Invoke(new object[] { result }); 
     SendMethod.Invoke(self, Flags, null, IsRunningInDotNetFourPointFive ? new[] { mailWriter, true, true } : new[] { mailWriter, true }, null); 
     result = new System.IO.MemoryStream(result.ToArray()); 
     CloseMethod.Invoke(mailWriter, Flags, null, new object[] { }, null); 
     return result; 
    } 
} 

Así ejemplo de Robert Reid se convertiría en

 using (var mailMessage = new MailMessage("fromaddress@blah.com", "toaddress@blah.com", "subject", "body")) 
     { 
      //Add an attachment just for the sake of it 
      Attachment doc = new Attachment(@"filePath"); 
      doc.ContentId = "doc"; 
      mailMessage.Attachments.Add(doc); 

      var smtpClient = new SmtpClient("SmtpHost") 
      { 
       EnableSsl = false, 
       DeliveryMethod = SmtpDeliveryMethod.Network 
      }; 

      // Apply credentials 
      smtpClient.Credentials = new NetworkCredential("smtpUsername", "smtpPassword"); 

      // Send 
      smtpClient.SendAndSaveMessageToIMAP(mailMessage, "imap.mail.com", 993, "imapUsername", "imapPassword", "SENT"); 
     }