it-swarm.com.de

Senden von E-Mails mit C #

Ich muss eine E-Mail über meine C # App senden.

Ich komme aus einem VB 6-Hintergrund und hatte viele schlechte Erfahrungen mit dem MAPI-Steuerelement . Erstens unterstützte MAPI keine HTML-E-Mails, und zweitens wurden alle E-Mails an meinen Standard-Postausgang gesendet. Also musste ich noch auf Senden klicken.

Wenn ich Massen-HTML-E-Mails (100 - 200) senden müsste, was wäre der beste Weg, dies in C # zu tun?

Danke im Voraus.

43
MegaByte

Sie können die Klasse System.Net.Mail.MailMessage des .NET-Frameworks verwenden.

Die Dokumentation zu MSDN finden Sie hier .

Hier ist ein einfaches Beispiel (Code-Snippet):

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

Die beste Methode zum Senden von Massen-E-Mails für einen schnelleren Weg ist die Verwendung von threads.Ich habe diese Konsolenanwendung für das Senden von Massen-E-Mails geschrieben.

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

Ich habe 10 Empfänger in der Array-Liste für ein Beispiel definiert. Es werden zwei Stapel von E-Mails erstellt, um zwei Thread-Pools zum Senden von Mails zu erstellen. Sie können auch die Details aus Ihrer Datenbank auswählen.

Sie können diesen Code verwenden, indem Sie ihn kopieren und in eine Konsolenanwendung einfügen (Ersetzen der Datei program.cs). Dann kann die Anwendung verwendet werden.

Ich hoffe das hilft dir :).

16
Vijaya Priya

Code:

using System.Net.Mail

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

Massenemails:

SMTP-Server haben in der Regel ein Limit für die Anzahl der Verbindungen, die auf einmal verarbeitet werden können. Wenn Sie versuchen, Hunderte von E-Mails zu senden, die Ihre Anwendung möglicherweise nicht mehr reagiert. 

Lösungen:  

  • Wenn Sie eine WinForm erstellen, verarbeiten Sie die Warteschlange mit einem BackgroundWorker. 
  • Wenn Sie einen IIS SMTP-Server oder einen SMTP-Server mit einem Postausgangsordner verwenden, können Sie SmtpClient () verwenden. PickupDirectoryLocation = "c:/smtp/outboxFolder"; Dadurch bleibt Ihr System ansprechbar. 
  • Wenn Sie keinen lokalen SMTP-Server verwenden, können Sie einen Systemdienst erstellen, der Filewatcher zum Überwachen eines Ordners verwendet, und verarbeitet dann alle E-Mails, die Sie dort ablegen.
7
rizzle

Das .NET-Framework verfügt über einige integrierte Klassen, mit denen Sie E-Mails über Ihre App versenden können.

Sie sollten einen Blick in den Namespace System.Net.Mail werfen, in dem Sie die Klassen MailMessage und SmtpClient finden .. Sie können das BodyFormat der MailMessage-Klasse auf MailFormat.Html setzen.

Es kann auch hilfreich sein, wenn Sie die AlternateViews-Eigenschaft der MailMessage-Klasse verwenden, sodass Sie eine Nur-Text-Version Ihrer E-Mails bereitstellen können, sodass sie von Clients gelesen werden kann, die kein HTML unterstützen.

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

4

Sie können E-Mails über SMTP oder CDO senden

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

quelle: C # SMTP-E-Mail

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

Quelle: C # CDO E-Mail

Männlich

3
Jerrym

Ich kann die aspNetEmail-Bibliothek dringend empfehlen: http://www.aspnetemail.com/

Der System.Net.Mail wird Sie irgendwo hinbringen, wenn Sie nur grundlegende Anforderungen haben. Wenn Sie jedoch Probleme haben, besuchen Sie aspNetEmail. Es hat mir eine Menge Zeit gespart, und ich kenne andere Entwickler, die auch darauf schwören!

2
JMS

Verwenden Sie den Namespace System.Net.Mail. Hier ist ein Link zur MSDN-Seite

Sie können E-Mails mit der SmtpClient-Klasse senden.

Ich habe das Codebeispiel paraphrasiert, also check MSDN für Details.

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

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

Der beste Weg, viele E-Mails zu versenden, wäre, so etwas in Forloop zu setzen und wegzuschicken!

1
bentford

Lass uns etwas als vollständige Lösung machen :). Vielleicht kann es auch helfen ... Es ist eine Lösung zum Senden eines E-Mail-Inhalts und einer Anhänge-Datei (oder ohne Anhänge) an viele E-Mail-Adressen. Natürlich ist auch das Senden einer einzigen E-Mail möglich. Ergebnis ist ein Listenobjekt mit Daten, was in Ordnung ist und was nicht.

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

Sie können Mailkit verwenden. MailKit ist eine plattformübergreifende Open-Source-E-Mail-Client-Bibliothek von Open Source, die auf MimeKit basiert und für mobile Geräte optimiert ist.

Es bietet mehr und bessere Funktionen als System.Net.Mail

  • Ein vollständig stornierbarer Pop3Client mit Unterstützung für STLS, UIDL, APOP, PIPELINING, UTF8 und LANG. Clientseitige Sortierung und Threading von -Nachrichten (das Ordinal Subject und die Jamie Zawinski-Threading -Algorithmen werden unterstützt).
  • Asynchrone Versionen aller Methoden, die das Netzwerk treffen.
  • S/MIME-, OpenPGP- und DKIM-Signaturunterstützung über MimeKit.
  • Microsoft TNEF-Unterstützung über MimeKit.

    Sie können von hier herunterladen.

In diesem Beispiel können Sie E-Mails senden 

            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

Schauen Sie sich die FluentEmail-Bibliothek an ... __ Ich habe darüber gebloggt hier

Sie haben ein schönes und fließendes API für Ihre Bedürfnisse:

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