net - Enviando un correo electrónico usando C#

enviar correos con asp net

Question

Necesito enviar un correo electrónico a través de mi aplicación C #.

Vengo de un entorno VB 6 y tuve muchas malas experiencias con el control MAPI. En primer lugar, MAPI no admitía correos electrónicos HTML y, en segundo lugar, todos los correos electrónicos se enviaban a mi buzón de correo predeterminado. Así que aún necesitaba hacer clic en enviar recibir.

Si tuviera que enviar correos masivos en formato html (100 - 200), ¿cuál sería la mejor manera de hacerlo en C #?

Gracias por adelantado.

Answer 1

.NET Framework tiene algunas clases integradas que le permiten enviar correos electrónicos a través de su aplicación.

Debería echar un vistazo en el espacio de nombres System.Net.Mail, donde encontrará las clases MailMessage y SmtpClient. Puede establecer el BodyFormat de la clase MailMessage en MailFormat.Html.

También podría ser útil si utiliza la propiedad AlternateViews de la clase MailMessage, para que pueda proporcionar una versión de texto sin formato para que los clientes que no son compatibles con HTML puedan leerla.

http://msdn.microsoft.com/en-us/library/system.net.mail.mailmessage.alternateviews.aspx

Answer 2

Eche un vistazo a la biblioteca FluentEmail. He escrito sobre esto here

Usted tiene una API agradable y fluida para sus necesidades:

Email.FromDefault()
 .To("[email protected]")
 .Subject("New order has arrived!")
 .Body("The order details are…")  
 .Send();

Answer 3

Hagamos algo como una solución completa :). Quizás también puede ayudar. Es una solución para enviar un contenido de correo electrónico y un archivo adjunto (o sin adjuntar) a muchas direcciones de correo electrónico. Por supuesto, enviar solo un correo electrónico también es posible. El resultado es el objeto Lista con datos, lo que está bien y lo que no.

namespace SmtpSendingEmialMessage
{ 
    public class EmailSetupData
    {
        public string EmailFrom { get; set; }
        public string EmailUserName { get; set; }
        public string EmailPassword { get; set; }
        public string EmailSmtpServerName { get; set; }
        public int EmailSmtpPortNumber { get; set; }
        public Boolean SSLActive { get; set; } = false;
    }

    public class SendingResultData
    {
        public string SendingEmailAddress { get; set; }
        public string SendingEmailSubject { get; set; }
        public DateTime SendingDateTime { get; set; }
        public Boolean SendingEmailSuccess { get; set; }
        public string SendingEmailMessage { get; set; }
    }
    public class OneRecData
    {
        public string RecEmailAddress { get; set; } = "";
        public string RecEmailSubject { get; set; } = "";
    }


    public class SendingProcess
    {
        public string EmailCommonSubjectOptional { get; set; } = "";
        private EmailSetupData EmailSetupParam { get; set; }
        private List<OneRecData> RecDataList { get; set; }
        private string EmailBodyContent { get; set; }
        private Boolean IsEmailBodyHtml { get; set; }
        private string EmailAttachFilePath { get; set; }

        public SendingProcess(List<OneRecData> MyRecDataList, String MyEmailTextContent, String MyEmailAttachFilePath, EmailSetupData MyEmailSetupParam, Boolean EmailBodyHtml)
        {
            RecDataList = MyRecDataList;
            EmailBodyContent = MyEmailTextContent;
            EmailAttachFilePath = MyEmailAttachFilePath;
            EmailSetupParam = MyEmailSetupParam;
            IsEmailBodyHtml = EmailBodyHtml;
        }

        public List<SendingResultData> SendAll()
        {
            List<SendingResultData> MyResList = new List<SendingResultData>();
            foreach (var js in RecDataList)
            {
                using (System.Net.Mail.MailMessage MyMes = new System.Net.Mail.MailMessage())
                {
                    DateTime SadaJe = DateTime.Now;
                    Boolean IsOK = true;
                    String MySendingResultMessage = "Sending OK";

                    String MessageSubject = EmailCommonSubjectOptional;
                    if (MessageSubject == "")
                    {
                        MessageSubject = js.RecEmailSubject;
                    }

                    try
                    {

                        System.Net.Mail.MailAddress MySenderAdd = new System.Net.Mail.MailAddress(js.RecEmailAddress);
                        MyMes.To.Add(MySenderAdd);
                        MyMes.Subject = MessageSubject;
                        MyMes.Body = EmailBodyContent;
                        MyMes.Sender = new System.Net.Mail.MailAddress(EmailSetupParam.EmailFrom);
                        MyMes.ReplyToList.Add(MySenderAdd);
                        MyMes.IsBodyHtml = IsEmailBodyHtml;

                    }
                    catch(Exception ex)
                    {
                        IsOK = false;
                        MySendingResultMessage ="Sender or receiver Email address error." +  ex.Message;
                    }

                    if (IsOK == true)
                    {
                        try
                        {
                            if (EmailAttachFilePath != null)
                            {
                                if (EmailAttachFilePath.Length > 5)
                                {
                                    MyMes.Attachments.Add(new System.Net.Mail.Attachment(EmailAttachFilePath));
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            IsOK = false;
                            MySendingResultMessage ="Emial attach error. " +  ex.Message;
                        }

                        if (IsOK == true)
                        {
                            using (System.Net.Mail.SmtpClient MyCl = new System.Net.Mail.SmtpClient())
                            {
                                MyCl.EnableSsl = EmailSetupParam.SSLActive;
                                MyCl.Host = EmailSetupParam.EmailSmtpServerName;
                                MyCl.Port = EmailSetupParam.EmailSmtpPortNumber;
                                try
                                {
                                    MyCl.Credentials = new System.Net.NetworkCredential(EmailSetupParam.EmailUserName, EmailSetupParam.EmailPassword);
                                }
                                catch (Exception ex)
                                {
                                    IsOK = false;
                                    MySendingResultMessage = "Emial credential error. " + ex.Message;
                                }

                                if (IsOK == true)
                                {
                                    try
                                    {
                                        MyCl.Send(MyMes);
                                    }
                                    catch (Exception ex)
                                    {
                                        IsOK = false;
                                        MySendingResultMessage = "Emial sending error. " + ex.Message;
                                    }
                                }
                            }
                        }
                    }

                    MyResList.Add(new SendingResultData
                    {
                            SendingDateTime = SadaJe,
                            SendingEmailAddress = js.RecEmailAddress,
                            SendingEmailMessage = MySendingResultMessage,
                            SendingEmailSubject = js.RecEmailSubject,
                            SendingEmailSuccess = IsOK
                    });
                }

            }
            return MyResList;
        }
    }

}

Answer 4

La mejor manera de enviar correos electrónicos masivos para una forma más rápida es usar hilos. He escrito esta aplicación de consola para enviar correos electrónicos masivos. He separado el ID de correo electrónico masivo en dos lotes creando dos grupos de hilos.

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Net.Mail;

namespace ConsoleApplication1
{
    public class SendMail 
    {
        string[] NameArray = new string[10] { "Recipient 1", 
                                              "Recipient 2",
                                              "Recipient 3",
                                              "Recipient 4", 
                                              "Recipient 5", 
                                              "Recipient 6", 
                                              "Recipient 7", 
                                              "Recipient 8",
                                              "Recipient 9",
                                              "Recipient 10"
                                            };        

        public SendMail(int i, ManualResetEvent doneEvent)
        {
            Console.WriteLine("Started sending mail process for {0} - ", NameArray[i].ToString() + " at " + System.DateTime.Now.ToString());
            Console.WriteLine("");
            SmtpClient mailClient = new SmtpClient();
            mailClient.Host = Your host name;
            mailClient.UseDefaultCredentials = true;
            mailClient.Port = Your mail server port number; // try with default port no.25

            MailMessage mailMessage = new MailMessage(FromAddress,ToAddress);//replace the address value
            mailMessage.Subject = "Testing Bulk mail application";
            mailMessage.Body = NameArray[i].ToString();
            mailMessage.IsBodyHtml = true;
            mailClient.Send(mailMessage);
            Console.WriteLine("Mail Sent succesfully for {0} - ",NameArray[i].ToString() + " at " + System.DateTime.Now.ToString());
            Console.WriteLine("");

            _doneEvent = doneEvent;
        }

        public void ThreadPoolCallback(Object threadContext)
        {
            int threadIndex = (int)threadContext;
            Console.WriteLine("Thread process completed for {0} ...",threadIndex.ToString() + "at" +  System.DateTime.Now.ToString());
            _doneEvent.Set();
        }      

        private ManualResetEvent _doneEvent;
    }


    public class Program
    {
        static int TotalMailCount, Mailcount, AddCount, Counter, i, AssignI;  
        static void Main(string[] args)
        {
            TotalMailCount = 10;
            Mailcount = TotalMailCount / 2;
            AddCount = Mailcount;
            InitiateThreads();                     

            Thread.Sleep(100000);
        }

       static void InitiateThreads()
       {
            //One event is used for sending mails for each person email id as batch
           ManualResetEvent[] doneEvents = new ManualResetEvent[Mailcount];

            // Configure and launch threads using ThreadPool:
            Console.WriteLine("Launching thread Pool tasks...");

            for (i = AssignI; i < Mailcount; i++)            
            {
                doneEvents[i] = new ManualResetEvent(false);
                SendMail SRM_mail = new SendMail(i, doneEvents[i]);
                ThreadPool.QueueUserWorkItem(SRM_mail.ThreadPoolCallback, i);
            }

            Thread.Sleep(10000);

            // Wait for all threads in pool to calculation...
            //try
            //{
            // //   WaitHandle.WaitAll(doneEvents);
            //}
            //catch(Exception e)
            //{
            //    Console.WriteLine(e.ToString());   
            //}

            Console.WriteLine("All mails are sent in this thread pool.");
            Counter = Counter+1;
            Console.WriteLine("Please wait while we check for the next thread pool queue");
            Thread.Sleep(5000);
            CheckBatchMailProcess();            
        }

        static  void CheckBatchMailProcess()
        {

            if (Counter < 2)
            {
                Mailcount = Mailcount + AddCount;
                AssignI = Mailcount - AddCount;
                Console.WriteLine("Starting the Next thread Pool");

                Thread.Sleep(5000);
                InitiateThreads();
            }

            else
            {
                Console.WriteLine("No thread pools to start - exiting the batch mail application");
                Thread.Sleep(1000);
                Environment.Exit(0);
            }
        }
    }   
}

He definido 10 receptores en la lista de arreglos para una muestra. Creará dos lotes de correos electrónicos para crear dos grupos de hilos para enviar correos. También puede elegir los detalles de su base de datos.

Puede usar este código copiándolo y pegándolo en una aplicación de consola. (Reemplazando el archivo program.cs). Luego la aplicación está lista para usar.

Espero que esto te ayude :).

Answer 5

Puede enviar correos electrónicos usando SMTP o CDO

usando SMTP:

mail.From = new MailAddress("[email protected]");
mail.To.Add("to_address");
mail.Subject = "Test Mail";
mail.Body = "This is for testing SMTP mail from GMAIL";

SmtpServer.Port = 587;
SmtpServer.Credentials = new System.Net.NetworkCredential("username", "password");
SmtpServer.EnableSsl = true;

fuente: C # SMTP Email

CDO.Message oMsg = new CDO.Message();
CDO.IConfiguration iConfg;
iConfg = oMsg.Configuration;
ADODB.Fields oFields;
oFields = iConfg.Fields;
ADODB.Field oField = oFields["http://schemas.microsoft.com/cdo/configuration/sendusing"];
oFields.Update();
oMsg.Subject = "Test CDO";
oMsg.From = "from_address";
oMsg.To = "to_address";
oMsg.TextBody = "CDO Mail test";
oMsg.Send();

Fuente: C # CDO Email

Varonil

Answer 6

Puede usar la clase System.Net.Mail.MailMessage de .NET framework.

Puede encontrar la documentación de MSDN aquí .

Aquí hay un ejemplo simple (fragmento de código):

using System.Net;
using System.Net.Mail;
using System.Net.Mime;

...
try
{

   SmtpClient mySmtpClient = new SmtpClient("my.smtp.exampleserver.net");

    // set smtp-client with basicAuthentication
    mySmtpClient.UseDefaultCredentials = false;
   System.Net.NetworkCredential basicAuthenticationInfo = new
      System.Net.NetworkCredential("username", "password");
   mySmtpClient.Credentials = basicAuthenticationInfo;

   // add from,to mailaddresses
   MailAddress from = new MailAddress("[email protected]", "TestFromName");
   MailAddress to = new MailAddress("[email protected]", "TestToName");
   MailMessage myMail = new System.Net.Mail.MailMessage(from, to);

   // add ReplyTo
   MailAddress replyto = new MailAddress("[email protected]");
   myMail.ReplyToList.Add(replyTo);

   // set subject and encoding
   myMail.Subject = "Test message";
   myMail.SubjectEncoding = System.Text.Encoding.UTF8;

   // set body-message and encoding
   myMail.Body = "<b>Test Mail</b><br>using <b>HTML</b>.";
   myMail.BodyEncoding = System.Text.Encoding.UTF8;
   // text or html
   myMail.IsBodyHtml = true;

   mySmtpClient.Send(myMail);
}

catch (SmtpException ex)
{
  throw new ApplicationException
    ("SmtpException has occured: " + ex.Message);
}
catch (Exception ex)
{
   throw ex;
}

Answer 7

Recomiendo encarecidamente la biblioteca aspNetEmail: http://www.aspnetemail.com/

El System.Net.Mail llevará a algún lado si sus necesidades son solo básicas, pero si tiene problemas, consulte aspNetEmail. Me ha ahorrado un montón de tiempo, ¡y sé de otros desarrolladores que también lo juran!

Answer 8

Use el espacio de nombres System.Net.Mail. Aquí hay un enlace a la página de MSDN

Puede enviar correos electrónicos utilizando la clase SmtpClient.

Parafraseé la muestra del código, así que echa un vistazo a MSDN para más detalles.

MailMessage message = new MailMessage(
   "[email protected]",
   "[email protected]",
   "Subject goes here",
   "Body goes here");

SmtpClient client = new SmtpClient(server);
client.Send(message);

¡La mejor manera de enviar muchos correos electrónicos sería poner algo así en todo y enviar!

Answer 9

Código:

using System.Net.Mail

new SmtpClient("smtp.server.com", 25).send("[email protected]", 
                                           "[email protected]", 
                                           "subject", 
                                           "body");

Correos electrónicos masivos:

Los servidores SMTP generalmente tienen un límite en el número de conexiones que puede manejar de una vez, si intenta enviar cientos de correos electrónicos, su aplicación puede parecer que no responde.

Soluciones:

• Si está construyendo un WinForm, use un BackgroundWorker para procesar la cola.
• Si está utilizando el servidor SMTP de IIS o un servidor SMTP que tiene una carpeta de la bandeja de salida, puede usar SmtpClient (). PickupDirectoryLocation = "c: / smtp / outboxFolder"; Esto mantendrá su sistema receptivo.
• Si no está utilizando un servidor SMTP local, podría crear un servicio del sistema para usar Filewatcher para monitorear un servidor que luego procesará los correos electrónicos que ingrese allí.