Använd SMTP-klienten för att skicka e‑post, vidarebefordra meddelanden och utföra mailmerge i C#

Skicka e‑post

Skicka e‑post med SmtpClient-klassen

Den SmtpClient klass möjliggör för applikationer att skicka e‑post via Simple Mail Transfer Protocol (SMTP).

En av dess nyckelfunktioner är förmågan att skicka meddelanden i bulk.

Den stöder också fullt ut synkron och asynkron programmeringsmodeller. För att skicka ett e‑post som blockerar huvudtråden tills operationen är klar, kan utvecklare använda en av de synkrona Skicka metoder. Alternativt, för att låta huvudtråden fortsätta köra medan e‑posten skickas, kan utvecklare använda SendAsync metod.

Dessutom, SmtpClient stödjer att skicka meddelanden i Transport Neutral Encapsulation Format (TNEF).

Skicka e‑post synkront

Ett e‑postmeddelande kan skickas synkront med Skicka metod för SmtpClient klass. Den skickar det angivna e‑postmeddelandet via en SMTP‑server för leverans. För att skicka ett e‑postmeddelande synkront, följ stegen nedan:

Skapa en instans av MailMessage klass och sätt dess egenskaper.
Skapa en instans av SmtpClient klass och ange värd, port, användarnamn & lösenord.
Skicka meddelandet med den Skicka metod för SmtpClient klass och skicka MailMessage instans.

Följande C#‑kodsnutt visar hur du skickar Outlook‑e‑postmeddelanden synkront.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Declare msg as MailMessage instance
MailMessage msg = new MailMessage();

// Create an instance of SmtpClient class
SmtpClient client = new SmtpClient();

// Specify your mailing host server, Username, Password, Port # and Security option
client.Host = "mail.server.com";
client.Username = "username";
client.Password = "password";
client.Port = 587;
client.SecurityOptions = SecurityOptions.SSLExplicit;

try
{
    // Client.Send will send this message
    client.Send(msg);
    Console.WriteLine("Message sent");
}
catch (Exception ex)
{
    Trace.WriteLine(ex.ToString());
}

Skicka e‑post asynkront

Ibland kan du vilja skicka e‑post asynkront så att programmet kan fortsätta utföra andra operationer medan e‑posten skickas i bakgrunden. Från .NET Framework 4.5 kan du använda asynkrona metoder implementerade enligt TAP modell. C#‑kodsnutten nedan visar hur man skickar Outlook‑e‑postmeddelanden med metoder baserade på task‑baserat asynkront mönster:

SendAsync Skickar de angivna meddelandena.
IAsyncSmtpClient - Tillåter applikationer att skicka meddelanden genom att använda Simple Mail Transfer Protocol (SMTP).
SmtpClient.CreateAsync - Skapar en ny instans av klassen Aspose.Email.Clients.Smtp.SmtpClient
SmtpSend - Aspose.Email.Clients.Smtp.IAsyncSmtpClient.SendAsync(Aspose.Email.Clients.Smtp.Models.SmtpSend)-metodens parameteruppsättning.
SmtpForward - Aspose.Email.Clients.Smtp.IAsyncSmtpClient.ForwardAsync(Aspose.Email.Clients.Smtp.Models.SmtpForward)-argumenten.

// Authenticate the client to obtain necessary permissions
static readonly string tenantId = "YOU_TENANT_ID";
static readonly string clientId = "YOU_CLIENT_ID";
static readonly string redirectUri = "http://localhost";
static readonly string username = "username";
static readonly string[] scopes = { "https://outlook.office.com/SMTP.Send" };

// Use the SmtpAsync method for asynchronous operations
static async Task Main(string[] args)
{
    await SmtpAsync();
    Console.ReadLine();
}

static async Task SmtpAsync()
{
    // Create token provider and get access token
    var tokenProvider = new TokenProvider(clientId, tenantId, redirectUri, scopes);
    var client = SmtpClient.CreateAsync("outlook.office365.com", username, tokenProvider, 587).GetAwaiter().GetResult();

    // Create a message to send
    var eml = new MailMessage("from@domain.com", "to@domain.com", "test subj async", "test body async");
    
    // send message
    var sendOptions = SmtpSend.Create();
    sendOptions.AddMessage(eml);
    await client.SendAsync(sendOptions);
    Console.WriteLine("message was sent");

    // forward message
    var fwdOptions = SmtpForward.Create();
    fwdOptions.SetMessage(eml);
    fwdOptions.AddRecipient("rec@domain.com");
    await client.ForwardAsync(fwdOptions);
    Console.WriteLine("message was forwarded");
}

// Token provider implementation
public class TokenProvider : IAsyncTokenProvider
{
    private readonly PublicClientApplicationOptions _pcaOptions;
    private readonly string[] _scopes;

    public TokenProvider(string clientId, string tenantId, string redirectUri, string[] scopes)
    {
        _pcaOptions = new PublicClientApplicationOptions
        {
            ClientId = clientId,
            TenantId = tenantId,
            RedirectUri = redirectUri
        };

        _scopes = scopes;
    }

    public async Task<OAuthToken> GetAccessTokenAsync(bool ignoreExistingToken = false, CancellationToken cancellationToken = default)
    {

        var pca = PublicClientApplicationBuilder
            .CreateWithApplicationOptions(_pcaOptions).Build();

        try
        {
            var result = await pca.AcquireTokenInteractive(_scopes)
                .WithUseEmbeddedWebView(false)
                .ExecuteAsync(cancellationToken);

            return new OAuthToken(result.AccessToken);
        }
        catch (MsalException ex)
        {
            Console.WriteLine($"Error acquiring access token: {ex}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex}");
        }

        return null;
    }

    public void Dispose()
    {

    }
}

Skicka meddelanden från disk

EML-filer innehåller ett huvud, meddelandetext och bilagor. Aspose.Email låter utvecklare arbeta med EML-filer på olika sätt. Detta avsnitt visar hur du laddar EML-filer från disk och skickar dem som e‑post med SMTP. Du kan ladda .eml-filer från disk eller ström in i MailMessage klass och skicka e‑postmeddelandet med SmtpClient klass. Den MailMessage klass är huvudklassen för att skapa nya e‑postmeddelanden, läsa in e‑postmeddelandefiler från disk eller ström och spara meddelandena. Följande C#‑kodsnutt visar hur man skickar lagrade meddelanden från disken.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Load an EML file in MailMessage class
var message = MailMessage.Load(dataDir + "test.eml");

// Send this message using SmtpClient
var client = new SmtpClient("host", "username", "password");
            
try
{
    client.Send(message);
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

Skicka e‑post i vanlig text

Den Kropp egenskap, en egenskap i MailMessage klass, som används för att specificera rentext‑innehållet i meddelandekroppen. För att skicka ett rentext‑e‑postmeddelande, följ dessa steg:

Skapa en instans av MailMessage klass.
Ange avsändar‑ och mottagare‑e‑postadresser i MailMessage instans.
Specificera Kropp innehåll, som används för rentext‑meddelandet.
Skapa en instans av SmtpClient klass och skicka e‑posten.

Följande kodsnutt visar hur du skickar ett rentext‑e‑postmeddelande.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
//Create an instance of the MailMessage class
var message = new MailMessage();

// Set From field, To field and Plain text body
message.From = "sender@sender.com";
message.To.Add("receiver@receiver.com");
message.Body = "This is Plain Text Body";

// Create an instance of the SmtpClient class
var client = new SmtpClient();

// And Specify your mailing host server, Username, Password and Port
client.Host = "smtp.server.com";
client.Username = "Username";
client.Password = "Password";
client.Port = 25;

try
{
    //Client.Send will send this message
    client.Send(message);
    Console.WriteLine("Message sent");
}
catch (Exception ex)
{
    System.Diagnostics.Trace.WriteLine(ex.ToString());
}

Skicka e‑post med HTML‑kropp

Programmeringsexemplen nedan visar hur du kan skicka ett enkelt HTML‑e‑postmeddelande. HtmlBody, en egenskap i MailMessage klass, som används för att specificera HTML‑innehållet i meddelandekroppen. För att skicka ett enkelt HTML‑e‑postmeddelande, följ dessa steg:

Skapa en instans av MailMessage klass.
Ange avsändar‑ och mottagare‑e‑postadress i MailMessage instans.
Specificera HtmlBody innehåll.
Skapa en instans av SmtpClient klass och skicka e‑posten med Skicka metod.

För syftet med den här artikeln är HTML‑innehållet i e‑posten rudimentärt: This is the HTML body De flesta HTML‑e‑postmeddelanden är mer komplexa. Följande kodsnutt visar hur du skickar ett e‑postmeddelande med HTML‑kropp.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
public static void Run()
{
    // Declare msg as MailMessage instance
    var msg = new MailMessage();

    // Use MailMessage properties like specify sender, recipient, message and HtmlBody
    msg.From = "newcustomeronnet@gmail.com";
    msg.To = "asposetest123@gmail.com";
    msg.Subject = "Test subject";
    msg.HtmlBody = "<html><body>This is the HTML body</body></html>";

    var client = GetSmtpClient();

    try
    {
        // Client will send this message
        client.Send(msg);
        Console.WriteLine("Message sent");
    }
    catch (Exception ex)
    {
        Trace.WriteLine(ex.ToString());
    }

    Console.WriteLine(Environment.NewLine + "Email sent with HTML body.");
}

private static SmtpClient GetSmtpClient()
{
    var client = new SmtpClient("smtp.gmail.com", 587, "your.email@gmail.com", "your.password");
    client.SecurityOptions = SecurityOptions.Auto;
    return client;
}

Skicka HTML‑e‑post med alternativ text

Använd AlternateView klass för att specificera kopior av ett e‑postmeddelande i olika format. Till exempel, om du skickar ett meddelande i HTML kan du även vilja tillhandahålla en vanlig text‑version för mottagare som använder e‑postläsare som inte kan visa HTML‑innehåll. Eller om du skickar ett nyhetsbrev kan du vilja ge en ren text‑kopia av innehållet till mottagare som har valt att få en ren text‑version. Följ dessa steg för att skicka ett e‑postmeddelande med alternativ text:

Skapa en instans av MailMessage klass.
Ange avsändar- och mottagare‑e‑postadresser i MailMessage instans.
Skapa en instans av AlternateView klass.

Detta skapar en alternativ vy för ett e‑postmeddelande med innehållet som anges i strängen.

Lägg till en instans av AlternateView klass till MailMessage objekt.
Skapa en instans av SmtpClient klass och skicka e‑posten med Skicka metod.

Följande kodsnutt visar hur du skickar ett e‑postmeddelande med alternativ text.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Declare message as MailMessage instance
var message = new MailMessage();

// Creates AlternateView to view an email message using the content specified in the //string
var alternate = AlternateView.CreateAlternateViewFromString("Alternate Text");
            
// Adding alternate text
message.AlternateViews.Add(alternate);

Skicka bulk‑e‑post

Vi kan skicka en bunt e‑post med hjälp av SmtpClient klass av Skicka metodöverkursning som accepterar en MailMessageCollection:

Skapa en instans av SmtpClient klass.
Specificera SmtpClient klassens egenskaper.
Skapa en instans av MailMessage klass.
Ange avsändare, mottagare, e‑postämne och meddelande i instansen av MailMessage klass.
Upprepa de två föregående stegen igen om du vill skicka e‑post till en annan person.
Skapa en instans av MailMessageCollection klass.
Lägg till en instans av MailMessage klassen i objektet av MailMessageCollection klass.
Skicka nu ditt e‑postmeddelande med SmtpClient klass Skicka metod genom att skicka en instans av MailMessageCollection klass i den.

Följande kodsnutt visar hur du skickar bulk‑e‑post.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Create SmtpClient as client and specify server, port, user name and password
var client = new SmtpClient("mail.server.com", 25, "Username", "Password");

// Create instances of MailMessage class and Specify To, From, Subject and Message
var message1 = new MailMessage("msg1@from.com", "msg1@to.com", "Subject1", "message1, how are you?");
var message2 = new MailMessage("msg1@from.com", "msg2@to.com", "Subject2", "message2, how are you?");
var message3 = new MailMessage("msg1@from.com", "msg3@to.com", "Subject3", "message3, how are you?");

// Create an instance of MailMessageCollection class
var manyMsg = new MailMessageCollection();
manyMsg.Add(message1);
manyMsg.Add(message2);
manyMsg.Add(message3);

try
{
    // Send Messages using Send method
    client.Send(manyMsg);                
    Console.WriteLine("Message sent");
}
catch (Exception ex)
{
    Trace.WriteLine(ex.ToString());
}

Spåra framgång för bulk‑e‑post

När du skickar meddelanden i bulk kan du få information om antalet framgångsrikt skickade meddelanden och till och med få en lista över dessa meddelanden. Den SucceededSending event är avsett för detta.

Kodexempel:

using (var client = new SmtpClient(host, SecurityOptions.Auto))
{
    int messageCount = 0;

    client.SucceededSending += (sender, eventArgs) =>
    {
        Console.WriteLine("The message '{0}' was successfully sent.", eventArgs.Message.Subject);
        messageCount++;
    };

    client.Send(messages);

    Console.WriteLine("{0} messages were successfully sent.", messageCount);
}

Skicka e‑post med MultiConnection

Den UseMultiConnection egenskapen kan användas för att skapa flera anslutningar för tunga operationer. Du kan också ange antalet anslutningar som ska användas under multikonnektionstillstånd genom att använda SmtpClient.ConnectionsQuantity. Följande kodsnutt demonstrerar användningen av multikonnectionsläget för att skicka flera meddelanden.

var smtpClient = new SmtpClient();
smtpClient.Host = "<HOST>";
smtpClient.Username = "<USERNAME>";
smtpClient.Password = "<PASSWORD>";
smtpClient.Port = 587;
smtpClient.SupportedEncryption = EncryptionProtocols.Tls;
smtpClient.SecurityOptions = SecurityOptions.SSLExplicit;

var messages = new List<MailMessage>();
for (int i = 0; i < 20; i++)
{
    MailMessage message = new MailMessage(
        "<EMAIL ADDRESS>",
        "<EMAIL ADDRESS>",
        "Test Message - " + Guid.NewGuid().ToString(),
        "SMTP Send Messages with MultiConnection");
    messages.Add(message);
}

smtpClient.ConnectionsQuantity = 5;
smtpClient.UseMultiConnection = MultiConnectionMode.Enable;
smtpClient.Send(messages);

Observera att användning av multikonnektion‑läge inte garanterar prestandaförbättring.

Skicka meddelanden som TNEF

TNEF-e‑post har speciell formatering som kan gå förlorad om den skickas med standard‑API:n. Den SmtpClient klass UseTnef egenskap kan ställas in för att skicka e‑posten som TNEF. Följande kodexempel visar hur du skickar ett meddelande som TNEF.

var emlFileName = RunExamples.GetDataDir_Email() + "Message.eml";     // A TNEF Email

// Load from eml
var eml1 = MailMessage.Load(emlFileName, new EmlLoadOptions());
eml1.From = "somename@gmail.com";
eml1.To.Clear();
eml1.To.Add(new MailAddress("first.last@test.com"));
eml1.Subject = "With PreserveTnef flag during loading";
eml1.Date = DateTime.Now;

var client = new SmtpClient("smtp.gmail.com", 587, "somename", "password");
client.SecurityOptions = SecurityOptions.Auto;
client.UseTnef = true;     // Use this flag to send as TNEF
client.Send(eml1);

Skicka mötesförfrågningar

Aspose.Email låter utvecklare lägga till kalenderfunktioner i dina e‑postmeddelanden.

Skicka förfrågningar via e‑post

För att skicka mötesförfrågningar via e‑post, följ dessa steg:

Skapa en instans av MailMessage klass.
Ange avsändar- och mottagaradresser med en instans av MailMessage klass.
Initiera en instans av Appointment klass och skicka dess värden.
Ange sammanfattning och beskrivning i Calendar instans.
Lägg till Calendar till MailMessage instans och skicka den Appointment instans.


// Create an instance of the MailMessage class
var msg = new MailMessage();

// Set the sender, recipient, who will receive the meeting request. Basically, the recipient is the same as the meeting attendees
msg.From = "newcustomeronnet@gmail.com";
msg.To = "person1@domain.com, person2@domain.com, person3@domain.com, asposetest123@gmail.com";

// Create Appointment instance
var app = new Appointment("Room 112", new DateTime(2015, 7, 17, 13, 0, 0), new DateTime(2015, 7, 17, 14, 0, 0), msg.From, msg.To);
app.Summary = "Release Meetting";
app.Description = "Discuss for the next release";

// Add appointment to the message and Create an instance of SmtpClient class
msg.AddAlternateView(app.RequestApointment());
var client = GetSmtpClient();

try
{
    // Client.Send will send this message
    client.Send(msg);
    Console.WriteLine("Message sent");
}
catch (Exception ex)
{
    Trace.WriteLine(ex.ToString());
}

Vidarebefordra meddelanden

Vidarebefordra meddelanden med SMTP-klient

Att vidarebefordra ett e‑postmeddelande är vanlig praxis. Ett mottaget e‑postmeddelande kan vidarebefordras till specifika mottagare. Den Vidarebefordra metoden kan användas för att vidarebefordra ett mottaget eller sparat e‑postmeddelande till önskade mottagare. Följande kodsnutt visar hur du vidarebefordrar ett e‑postmeddelande med SMTP-klienten.

//Create an instance of SmtpClient class
var client = new SmtpClient();

// Specify your mailing host server, Username, Password, Port and SecurityOptions
client.Host = "mail.server.com";
client.Username = "username";
client.Password = "password";
client.Port = 587;
client.SecurityOptions = SecurityOptions.SSLExplicit;
var message = MailMessage.Load(dataDir + "Message.eml");
client.Forward("Recipient1@domain.com", "Recipient2@domain.com", message);

Vidarebefordra meddelanden utan MailMessage

API:et stödjer även att vidarebefordra EML‑meddelanden utan att först ladda in i MailMessage. Detta är användbart i fall där det finns begränsade resurser avseende systemminne.


using (var client = new SmtpClient(host, smtpPort, username, password, SecurityOptions.Auto))
{
    using (var fs = File.OpenRead(@"test.eml"))
    {
        client.Forward(sender, recipients, fs);
    }
}

Vidarebefordra meddelanden asynkront utan MailMessage

using (var client = new SmtpClient(host, smtpPort, username, password))
{
    using (var fs = File.OpenRead(@"test.eml"))
    {
        await client.ForwardAsync(sender, recipients, fs);
    }
}

Mail Merge

Hur man slår ihop e‑post

Mailfusioner hjälper dig att skapa och skicka en grupp av liknande e‑postmeddelanden. Kärnan i e‑postmeddelandena är densamma, men innehållet kan personifieras. Vanligtvis används mottagarens kontaktuppgifter (förnamn, efternamn, företag osv.) för att personifiera e‑posten.

|Illustration av hur en mail merge fungerar:| | :- | | todo:image_alt_text | Aspose.Email låter utvecklare skapa mail merges som inkluderar data från en mängd olika datakällor.

För att utföra en postfusion med Aspose.Email, följ dessa steg:

Skapa en funktion med namnsignaturen
Skapa en instans av MailMessage klass.
Ange avsändare, mottagare, ämne och meddelandetext.
Skapa en signatur för slutet av e‑postmeddelandet.
Skapa en instans av TemplateEngine klass och skicka den till MailMessage instans.
Ta signatur i TemplateEngine instans.
Skapa en instans av DataTable-klassen.
Lägg till kolumnerna Receipt, FirstName och LastName som datakällor i DataTable-klassen.
Skapa en instans av DataRow-klassen.
Ange mottagaradressen, för- och efternamn i DataRow-objektet.
Skapa en instans av MailMessageCollection klass
Specificera TemplateEngine och DataTable‑instanser i MailMessageCollection instans.
Skapa en instans av SmtpClient klass och ange server, port, användarnamn och lösenord.
Skicka e‑post med SmtpClient klass Skicka metod.

I exemplet nedan indikerar #FirstName# en DataTable-kolumn vars värde sätts av användaren. Följande kodsnutt visar hur du utför Mail Merge.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
public static void Run()
{
    // The path to the File directory.
    string dataDir = RunExamples.GetDataDir_SMTP();
    string dstEmail = dataDir + "EmbeddedImage.msg";

    // Create a new MailMessage instance
    MailMessage msg = new MailMessage();

    // Add subject and from address
    msg.Subject = "Hello, #FirstName#";
    msg.From = "sender@sender.com";

    // Add email address to send email also Add mesage field to HTML body
    msg.To.Add("your.email@gmail.com");
    msg.HtmlBody = "Your message here";
    msg.HtmlBody += "Thank you for your interest in <STRONG>Aspose.Email</STRONG>.";

    // Use GetSignment as the template routine, which will provide the same signature
    msg.HtmlBody += "<br><br>Have fun with it.<br><br>#GetSignature()#";

    // Create a new TemplateEngine with the MSG message,  Register GetSignature routine. It will be used in MSG.
    TemplateEngine engine = new TemplateEngine(msg);
    engine.RegisterRoutine("GetSignature", GetSignature);

    // Create an instance of DataTable and Fill a DataTable as data source
    DataTable dt = new DataTable();
    dt.Columns.Add("Receipt", typeof(string));
    dt.Columns.Add("FirstName", typeof(string));
    dt.Columns.Add("LastName", typeof(string));

    DataRow dr = dt.NewRow();
    dr["Receipt"] = "abc<asposetest123@gmail.com>";
    dr["FirstName"] = "a";
    dr["LastName"] = "bc";
    dt.Rows.Add(dr);
    dr = dt.NewRow();
    dr["Receipt"] = "John<email.2@gmail.com>";
    dr["FirstName"] = "John";
    dr["LastName"] = "Doe";
    dt.Rows.Add(dr);
    dr = dt.NewRow();
    dr["Receipt"] = "Third Recipient<email.3@gmail.com>";
    dr["FirstName"] = "Third";
    dr["LastName"] = "Recipient";
    dt.Rows.Add(dr);

    MailMessageCollection messages;
    try
    {
        // Create messages from the message and datasource.
        messages = engine.Instantiate(dt);

        // Create an instance of SmtpClient and specify server, port, username and password
        SmtpClient client = new SmtpClient("smtp.gmail.com", 587, "your.email@gmail.com", "your.password");
        client.SecurityOptions = SecurityOptions.Auto;

        // Send messages in bulk
        client.Send(messages);
    }
    catch (MailException ex)
    {
        Debug.WriteLine(ex.ToString());
    }

    catch (SmtpException ex)
    {
        Debug.WriteLine(ex.ToString());
    }

    Console.WriteLine(Environment.NewLine + "Message sent after performing mail merge.");
}

// Template routine to provide signature
static object GetSignature(object[] args)
{
    return "Aspose.Email Team<br>Aspose Ltd.<br>" + DateTime.Now.ToShortDateString();
}

Hur man utför radvis mail‑merge

Användaren kan slå samman enskilda datarader samt få ett komplett och färdigt MailMessage objektet. Det TemplateEngine.Merge metod kan användas för att utföra en rad‑vis mail merge.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Create message from the data in current row.
message = engine.Merge(currentRow);

Ansluta till SMTP‑server Aktivera SMTP-aktivitetsloggning i .NET med appsettings.json