Usa il client SMTP per inviare email, inoltrare messaggi e effettuare Mail Merge in C#

Invio di email

Invia email con la classe SmtpClient

Il SmtpClient la classe consente alle applicazioni di inviare email tramite il Simple Mail Transfer Protocol (SMTP).

Una delle sue caratteristiche chiave è la capacità di l’invio di messaggi in blocco.

Supporta pienamente anche sincrono e asincrono modelli di programmazione. Per trasmettere un’email bloccando il thread principale fino al completamento dell’operazione, gli sviluppatori possono utilizzare una delle modalità sincrone Invia metodi. In alternativa, per consentire al thread principale di continuare ad eseguire operazioni mentre l’email è in fase di invio, gli sviluppatori possono utilizzare il SendAsync metodo.

Inoltre, SmtpClient supporta l’invio di messaggi in Transport Neutral Encapsulation Format (TNEF).

Invia Email in Modo Sincrono

Un messaggio email può essere inviato in modo sincrono usando il Invia metodo del SmtpClient classe. Invia il messaggio email specificato attraverso un server SMTP per la consegna. Per inviare un messaggio email in modo sincrono, segui i passaggi riportati di seguito:

Crea un’istanza di MailMessage classe e imposta le sue proprietà.
Crea un’istanza di SmtpClient classe e specifica Host, porta, nome utente e Password.
Invia il Messaggio usando il Invia metodo del SmtpClient classe e passa il MailMessage istanza.

Il seguente frammento di codice C# mostra come inviare email Outlook in modo sincrono.

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

Invia email in modo asincrono

A volte, potresti voler inviare email in modo asincrono per consentire al programma di continuare ad eseguire altre operazioni mentre l’email viene inviata in background. A partire da .NET Framework 4.5, è possibile utilizzare i metodi asincroni implementati secondo TAP modello. Il frammento di codice C# qui sotto mostra come inviare messaggi email Outlook usando i metodi basati su pattern asincrono basato su task:

SendAsync Invia i messaggi specificati.
IAsyncSmtpClient - Consente alle applicazioni di inviare messaggi usando Simple Mail Transfer Protocol (SMTP).
SmtpClient.CreateAsync - Crea una nuova istanza della classe Aspose.Email.Clients.Smtp.SmtpClient
SmtpSend - Il set di parametri del metodo Aspose.Email.Clients.Smtp.IAsyncSmtpClient.SendAsync(Aspose.Email.Clients.Smtp.Models.SmtpSend).
SmtpForward - Gli argomenti di Aspose.Email.Clients.Smtp.IAsyncSmtpClient.ForwardAsync(Aspose.Email.Clients.Smtp.Models.SmtpForward).

// 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()
    {

    }
}

Invia messaggi dal disco

I file EML contengono un’intestazione, il corpo del messaggio e allegati. Aspose.Email permette agli sviluppatori di lavorare con i file EML in diversi modi. Questa sezione mostra come caricare file EML dal disco e inviarli come email con SMTP. È possibile caricare file .eml dal disco o dallo stream nel MailMessage classe e invia il messaggio email usando il SmtpClient classe. Il MailMessage la classe è la classe principale per creare nuovi messaggi email, caricare file di messaggi email da disco o stream e salvare i messaggi. Il seguente frammento di codice C# mostra come inviare i messaggi memorizzati dal disco.

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

Invia email in testo semplice

Il Body proprietà, una proprietà della MailMessage classe, è usata per specificare il contenuto in testo semplice del corpo del messaggio. Per inviare un messaggio email in testo semplice, segui questi passaggi:

Crea un’istanza di MailMessage classe.
Specifica gli indirizzi email del mittente e del destinatario nella MailMessage istanza.
Specificare il Body contenuto, usato per il messaggio in testo semplice.
Crea un’istanza di SmtpClient classe e invia l’email.

Il seguente frammento di codice mostra come inviare un’email in testo semplice.

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

Invia email con corpo HTML

Gli esempi di programmazione di seguito mostrano come poter inviare un semplice messaggio email HTML. Il HtmlBody, una proprietà della MailMessage classe, è usata per specificare il contenuto HTML del corpo del messaggio. Per inviare una semplice email HTML, segui questi passaggi:

Crea un’istanza di MailMessage classe.
Specifica l’indirizzo email del mittente e del destinatario nella MailMessage istanza.
Specificare il HtmlBody contenuto.
Crea un’istanza di SmtpClient classe e invia l’email usando il Invia metodo.

Ai fini di questo articolo, il contenuto HTML dell’email è rudimentale: Questo è il corpo HTML La maggior parte delle email HTML sarà più complessa. Il frammento di codice qui sotto mostra come inviare un’email con corpo HTML.

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

Invia email HTML con testo alternativo

Usa il AlternateView classe per specificare copie di un messaggio email in diversi formati. Ad esempio, se invii un messaggio in HTML, potresti anche voler fornire una versione testo semplice per i destinatari che usano client email che non possono visualizzare contenuti HTML. Oppure, se invii una newsletter, potresti voler fornire una copia in testo semplice per i destinatari che hanno scelto di ricevere una versione in testo semplice. Per inviare un’email con testo alternativo, segui questi passaggi:

Crea un’istanza di MailMessage classe.
Specifica gli indirizzi email del mittente e del destinatario nella MailMessage istanza.
Crea un’istanza di AlternateView classe.

Questo crea una visualizzazione alternativa per un messaggio email usando il contenuto specificato nella stringa.

Aggiungi l’istanza della AlternateView classe al MailMessage oggetto.
Crea un’istanza di SmtpClient classe e invia l’email usando il Invia metodo.

Il seguente frammento di codice mostra come inviare un’email con testo alternativo.

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

Invia email in blocco

Possiamo inviare un batch di email usando il SmtpClient classe di Invia sovraccarico del metodo che accetta un MailMessageCollection:

Crea un’istanza di SmtpClient classe.
Specificare il SmtpClient proprietà della classe.
Crea un’istanza di MailMessage classe.
Specifica mittente, destinatario, oggetto dell’email e messaggio nell’istanza della MailMessage classe.
Ripeti i due passaggi sopra, se desideri inviare email a una persona diversa.
Crea un’istanza di MailMessageCollection classe.
Aggiungi un’istanza di MailMessage classe nell’oggetto del MailMessageCollection classe.
Ora invia la tua email usando il SmtpClient classe Invia metodo passando l’istanza di MailMessageCollection classe in esso.

Il seguente frammento di codice mostra come inviare email in blocco.

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

Traccia il successo delle email in blocco

Quando invii messaggi in blocco, puoi ottenere informazioni sul numero di messaggi inviati con successo e persino una lista di questi messaggi. Il SucceededSending l’evento è pensato per questo scopo.

Esempio di codice:

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

Invia email con MultiConnection

Il UseMultiConnection la proprietà può essere usata per creare più connessioni per operazioni intensive. È inoltre possibile impostare il numero di connessioni da usare durante la modalità multiconnessione usando SmtpClient.ConnectionsQuantity. Il seguente frammento di codice dimostra l’uso della modalità multiconnessione per l’invio di più messaggi.

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

Nota che l’uso della modalità multiconnessione non garantisce un aumento delle prestazioni.

Invia messaggi come TNEF

Le email TNEF hanno una formattazione speciale che può andare persa se inviata usando l’API standard. Il SmtpClient classe UseTnef la proprietà può essere impostata per inviare l’email come TNEF. Il seguente snippet di codice mostra come inviare un messaggio come 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);

Invia richieste di riunione

Aspose.Email permette agli sviluppatori di aggiungere funzioni di calendario alle tue email.

Invia richieste via email

Per inviare richieste di riunione via email, segui questi passaggi:

Crea un’istanza di MailMessage classe.
Specifica gli indirizzi mittente e destinatario usando un’istanza di MailMessage classe.
Inizializza un’istanza di Appointment classe e passa i suoi valori.
Specifica riepilogo e descrizione nel Calendar istanza.
Aggiungi il/la Calendar al MailMessage istanza e passagli il Appointment istanza.


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

Inoltra messaggi

Inoltra messaggi con il client SMTP

Inoltrare un’email è una pratica comune. Un’email ricevuta può essere inoltrata a destinatari specifici. Il Inoltra il metodo può essere usato per inoltrare un’email ricevuta o salvata ai destinatari desiderati. Il seguente frammento di codice mostra come inoltrare un’email usando il client SMTP.

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

Inoltra messaggi senza MailMessage

L’API supporta anche l’inoltro di messaggi EML senza prima caricarli in MailMessage. Questo è utile nei casi in cui le risorse di memoria di sistema sono limitate.


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

Inoltra messaggi in modo asincrono senza 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

Come unire le email

Le fusioni di stampa ti aiutano a creare e inviare un batch di messaggi email simili. Il nucleo delle email è lo stesso, ma il contenuto può essere personalizzato. Tipicamente, i dettagli di contatto del destinatario (nome, cognome, azienda, ecc.) vengono usati per personalizzare l’email.

|Illustrazione di come funziona una merge di posta:| | :- | | todo:image_alt_text | Aspose.Email consente agli sviluppatori di configurare merge di posta che includono dati da varie fonti di dati.

Per eseguire un’unione di stampa (mail merge) con Aspose.Email, segui questi passaggi:

Crea una funzione con la firma del nome
Crea un’istanza di MailMessage classe.
Specifica mittente, destinatario, oggetto e corpo.
Crea una firma per la conclusione dell’email.
Crea un’istanza di TemplateEngine classe e passagli il MailMessage istanza.
Prendi la firma nel TemplateEngine istanza.
Crea un’istanza della classe DataTable.
Aggiungi le colonne Receipt, FirstName e LastName come data source nella classe DataTable.
Crea un’istanza della classe DataRow.
Specifica l’indirizzo di ricezione, il nome e il cognome nell’oggetto DataRow.
Crea un’istanza di MailMessageCollection classe
Specificare il TemplateEngine e istanze DataTable nel MailMessageCollection istanza.
Crea un’istanza di SmtpClient classe e specifica server, porta, nome utente e password.
Invia email usando il SmtpClient classe Invia metodo.

Nel campione qui sotto, #FirstName# indica una colonna di DataTable, il cui valore è impostato dall’utente. Il frammento di codice seguente mostra come eseguire il 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();
}

Come effettuare Mail Merge riga per riga

L’utente può unire una singola riga di dati così come ottenere un completo e pronto MailMessage oggetto. Il TemplateEngine.Merge metodo può essere usato per eseguire un’unione mail riga per riga.

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

Connessione al Server SMTP Abilita il logging delle attività SMTP in .NET usando appsettings.json