E-mail verzenden met C#

Ik moet e-mail verzenden via mijn C#-app.

Ik kom uit een VB 6-achtergrond en had veel slechte ervaringen met de MAPI-besturing.
Ten eerste ondersteunde MAPI geen HTML-e-mails en ten tweede werden alle e-mails naar mijn standaard postvak uit gestuurd. Ik moest dus nog steeds op verzenden en ontvangen klikken.

Als ik bulk e-mails met HTML-inhoud (100 – 200) zou moeten verzenden, wat zou dan de beste manier zijn om dit in C# te doen?


Antwoord 1, autoriteit 100%

U kunt de klasse System.Net.Mail.MailMessagevan het .NET-framework gebruiken.

U vindt de MSDN documentatie hier.

Hier is een eenvoudig voorbeeld (codefragment):

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

Antwoord 2, autoriteit 19%

De beste manier om bulk-e-mails te verzenden voor een snellere manier, is door threads te gebruiken. Ik heb deze consoletoepassing geschreven voor het verzenden van bulk-e-mails. Ik heb de bulk-e-mail-ID in twee batches gescheiden door twee threadpools te maken.

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

Ik heb 10 ontvangers gedefinieerd in de arraylijst voor een voorbeeld. Er worden twee batches e-mails gemaakt om twee threadpools te maken om e-mails te verzenden. U kunt de details ook uit uw database halen.

U kunt deze code gebruiken door deze te kopiëren en in een consoletoepassing te plakken.(Vervang het programma.cs-bestand). Dan is de toepassing klaar voor gebruik.

Ik hoop dat dit je helpt :).


Antwoord 3, autoriteit 15%

Code:

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

Massa-e-mails:

SMTP-servers hebben meestal een limiet op het aantal verbindingen dat tegelijkertijd kan worden verwerkt. Als u honderden e-mails probeert te verzenden, lijkt uw toepassing mogelijk niet meer te reageren.

Oplossingen:

  • Als je een WinForm aan het bouwen bent, gebruik dan een BackgroundWorker om de wachtrij te verwerken.
  • Als u een IIS SMTP-server of een SMTP-server met een outbox-map gebruikt, kunt u SmtpClient().PickupDirectoryLocation = “c:/smtp/outboxFolder” gebruiken; Dit zorgt ervoor dat uw systeem responsief blijft.
  • Als u geen lokale SMTP-server gebruikt, kunt u een systeemservice bouwen om Filewatcher te gebruiken om een ​​document te controleren, dan alle e-mails die u daar binnenlaat, verwerkt.

Antwoord 4, autoriteit 5%

Het .NET-framework heeft enkele ingebouwde klassen waarmee u e-mail kunt verzenden via uw app.

Je zou eens in de System.Net.Mail-naamruimte moeten kijken, waar je de klassen MailMessage en SmtpClient vindt.
U kunt de BodyFormat van de klasse MailMessage instellen op MailFormat.Html.

Het kan ook handig zijn als u gebruik maakt van de eigenschap AlternateViews van de klasse MailMessage, zodat u een platte tekstversie van uw e-mail kunt leveren, zodat deze kan worden gelezen door clients die geen HTML ondersteunen.

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


Antwoord 5, autoriteit 3%

U kunt e-mail verzenden via SMTP of CDO

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

met behulp van CDO

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

Bron: C# SMTP-e-mail

Bron: C# CDO-e-mail


Antwoord 6, autoriteit 2%

Ik kan de aspNetEmail-bibliotheek ten zeerste aanbevelen: http://www.aspnetemail.com/

De System.Net.Mailzal je ergens brengen als je behoeften alleen basis zijn, maar als je in de problemen komt, kijk dan eens naar aspNetEmail. Het heeft me een hoop tijd bespaard en ik ken andere ontwikkelaars die er ook bij zweren!


Antwoord 7

Gebruik de naamruimte System.Net.Mail. Hier is een link naar de MSDN pagina

U kunt e-mails verzenden met de SmtpClient-klasse.

Ik heb het codevoorbeeld geparafraseerd, dus check MSDN voor details.

MailMessage message = new MailMessage(
   "[email protected]",
   "[email protected]",
   "Subject goes here",
   "Body goes here");
SmtpClient client = new SmtpClient(server);
client.Send(message);

De beste manier om veel e-mails te verzenden, is door zoiets in forloop te plaatsen en weg te sturen!


Antwoord 8

Bekijk de FluentEmail-bibliotheek.
Ik heb erover geblogd hier

Je hebt een mooie en vloeiende api voor je behoeften:

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

Antwoord 9

Laten we er iets van maken als een volledige oplossing :). Misschien kan het ook helpen.
Het is een oplossing voor het verzenden van één e-mailinhoud en één bijlagebestand (of zonder bijlage) naar vele e-mailadressen. Eén e-mail sturen is natuurlijk ook mogelijk. Resultaat is Lijstobject met gegevens wat in orde is en wat niet.

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

10

Hieronder de bijgevoegde oplossing werkt u via de lokale machine en server.

    public static string SendMail(string bodyContent)
    {
        string sendMail = "";
        try
        {
            string fromEmail = "[email protected]";
            MailMessage mailMessage = new MailMessage(fromEmail, "[email protected]", "Subject", body);
            mailMessage.IsBodyHtml = true;
            SmtpClient smtpClient = new SmtpClient("smtp.gmail.com", 587);
            smtpClient.EnableSsl = true;
            smtpClient.UseDefaultCredentials = false;
            smtpClient.Credentials = new NetworkCredential(fromEmail, frompassword);
            smtpClient.Send(mailMessage);
        }
        catch (Exception ex)
        {
            sendMail = ex.Message.ToString();
            Console.WriteLine(ex.ToString());
        }
        return sendMail;
    }

Antwoord 11

  public string sendEmail(string mail,string subject, string body)
   {
       try
       {
           MailMessage message = new MailMessage();
           SmtpClient smtp = new SmtpClient();
           message.From = new MailAddress("[email protected]");
           message.To.Add(new MailAddress(mail));
           message.Subject = subject;
           message.IsBodyHtml = true; //to make message body as html  
           message.Body = body;
           smtp.Port = 587;
           smtp.Host = "smtp.gmail.com"; //for gmail host  
           smtp.EnableSsl = true;
           smtp.UseDefaultCredentials = false;
           smtp.Credentials = new NetworkCredential("[email protected]", "password");
           smtp.DeliveryMethod = SmtpDeliveryMethod.Network;
           smtp.Send(message);
           return "success";
       }
       catch (Exception e) {
           return e.Message;
       }
   }‏

Other episodes