web-dev-qa-db-fra.com

Envoi de courrier électronique à l'aide de C #

Je dois envoyer un email via mon application C #.

Je viens d'un VB 6 et ai eu beaucoup de mauvaises expériences avec le contrôle MAPI . Tout d'abord, MAPI ne supportait pas les emails HTML et ensuite, tous les emails étaient envoyés à mon courrier par défaut boîte d'envoi. Il me fallait donc toujours cliquer sur envoyer, recevoir.

Si j'avais besoin d'envoyer des emails en masse HTML en masse (100 - 200), quel serait le meilleur moyen de le faire en C #?

Merci d'avance.

43
MegaByte

Vous pouvez utiliser la classe System.Net.Mail.MailMessage du framework .NET.

Vous pouvez trouver la documentation MSDN ici .

Voici un exemple simple (extrait de code):

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;
}
69
splattne

Le meilleur moyen d’envoyer des courriers électroniques en masse pour un traitement plus rapide consiste à utiliser threads.J'ai écrit cette application console pour envoyer des courriers électroniques en masse.

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

J'ai défini 10 destinataires dans la liste de tableaux pour un exemple. Il créera deux lots d'e-mails afin de créer deux pools de threads pour l'envoi d'e-mails.Vous pouvez également sélectionner les détails dans votre base de données.

Vous pouvez utiliser ce code en le copiant et en le collant dans une application console. (Remplacement du fichier program.cs) .L'application est prête à être utilisée.

J'espère que ceci vous aide :).

16
Vijaya Priya

Code:

using System.Net.Mail

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

Mass Emails:

Les serveurs SMTP ont généralement une limite sur le nombre de connexions pouvant être gérées simultanément. Si vous essayez d'envoyer des centaines de courriels, votre application risque de ne pas répondre. 

Solutions:  

  • Si vous créez un formulaire WinForm, utilisez un outil BackgroundWorker pour traiter la file d'attente. 
  • Si vous utilisez un serveur SMTP IIS ou un serveur SMTP qui possède un dossier de boîte d'envoi, vous pouvez utiliser SmtpClient (). Cela permettra à votre système de rester réactif. 
  • Si vous n'utilisez pas de serveur SMTP local, vous pouvez créer un service système permettant à Filewatcher de surveiller un courrier électronique, puis traitera les courriers électroniques que vous y déposerez.
7
rizzle

Le framework .NET comporte des classes intégrées qui vous permettent d’envoyer des courriers électroniques via votre application.

Vous devriez jeter un coup d'oeil dans l'espace de noms System.Net.Mail, où vous trouverez les classes MailMessage et SmtpClient . Vous pouvez définir le BodyFormat de la classe MailMessage sur MailFormat.Html.

Cela pourrait également être utile si vous utilisiez la propriété AlternateViews de la classe MailMessage, afin de pouvoir fournir une version en texte brut de votre courrier afin qu'il puisse être lu par les clients qui ne prennent pas en charge le langage HTML.

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

4
Frederik Gheysels

Vous pouvez envoyer un email en utilisant SMTP ou CDO

en utilisant 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;

source: Email C # SMTP

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

Source: Email C # CDO

Viril

3
Jerrym

Je peux fortement recommander la bibliothèque aspNetEmail: http://www.aspnetemail.com/

Le System.Net.Mail vous mènera quelque part si vos besoins ne sont que de base, mais si vous rencontrez des problèmes, veuillez vous rendre sur aspNetEmail. Cela m'a fait gagner beaucoup de temps et je connais d’autres pays en développement qui jurent aussi!

2
JMS

Utilisez l'espace de noms System.Net.Mail. Voici un lien vers la page MSDN

Vous pouvez envoyer des emails en utilisant la classe SmtpClient.

J'ai paraphrasé l'exemple de code, vérifiez donc MSDN pour plus de détails.

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

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

La meilleure façon d’envoyer de nombreux courriels serait de mettre quelque chose comme cela dans forloop et de l’envoyer!

1
bentford

Faisons quelque chose comme une solution complète :). Peut-être que cela peut aussi aider ... C'est une solution pour envoyer un seul contenu de courrier électronique et un seul fichier joint (ou sans pièce jointe) à plusieurs adresses électroniques. Bien sûr, l'envoi d'un seul courriel est également une possibilité. Le résultat est un objet List avec data, ce qui est correct et ce qui ne l'est pas.

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

}
0
user2721448

Vous pouvez utiliser Mailkit.MailKit est une bibliothèque de client de messagerie .NET multiplate-forme Open Source basée sur MimeKit et optimisée pour les appareils mobiles.

Il a plus de fonctionnalités avancées et mieux que System.Net.Mail

  • Pop3Client entièrement annulable avec prise en charge de STLS, UIDL, APOP, PIPELINING, UTF8 et LANG. Tri et filetage des messages .__ côté client (les algorithmes de traitement du sujet ordinal et de Jamie Zawinski Sont pris en charge).
  • Les versions asynchrones de toutes les méthodes qui frappent le réseau.
  • Prise en charge des signatures S/MIME, OpenPGP et DKIM via MimeKit.
  • Prise en charge de Microsoft TNEF via MimeKit.

    Vous pouvez télécharger depuis ici .

Voir cet exemple, vous pouvez envoyer un mail 

            MimeMessage mailMessage = new MimeMessage();
            mailMessage.From.Add(new MailboxAddress(senderName, [email protected]));
            mailMessage.Sender = new MailboxAddress(senderName, [email protected]);
            mailMessage.To.Add(new MailboxAddress(emailid, emailid));
            mailMessage.Subject = subject;
            mailMessage.ReplyTo.Add(new MailboxAddress(replyToAddress));
            mailMessage.Subject = subject;
            var builder = new BodyBuilder();
            builder.TextBody = "Hello There";            
            try
            {
                using (var smtpClient = new SmtpClient())
                {
                    smtpClient.Connect("HostName", "Port", MailKit.Security.SecureSocketOptions.None);
                    smtpClient.Authenticate("[email protected]", "password");

                    smtpClient.Send(mailMessage);
                    Console.WriteLine("Success");
                }
            }
            catch (SmtpCommandException ex)
            {
                Console.WriteLine(ex.ToString());              
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());                
            }
0
Naveen Soni

Jetez un coup d'œil à la bibliothèque FluentEmail ... J'ai écrit un blog à ce sujet ici

Vous avez une belle et bonne API pour vos besoins:

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