Invio e inoltro di messaggi - Invia messaggi email Outlook usando programma Java

Il SmtpClient classe permette alle applicazioni di inviare email usando il Simple Mail Transfer Protocol (SMTP).

Il SmtpClient classe è l’unico principale punto di ingresso che gli sviluppatori usano per inviare messaggi di posta.
Il SmtpClient classe fornisce anche altri metodi comuni di consegna email, inclusa la scrittura di messaggi email sul file system, code di messaggi ecc.
Il SmtpClient classe supporta pienamente questi due modelli di programmazione:
- Sincrono
- Asincrono
Il SmtpClient classe supporta anche invio di messaggi come TNEF

Per inviare il messaggio email e bloccare l’esecuzione in attesa che l’email venga trasmessa al server SMTP, usa uno dei metodi Send sincroni. Per consentire al thread principale del programma di continuare a eseguire mentre l’email viene trasmessa, usa il beginSend metodo.

Invio di Email in Sincrono

Un messaggio email può essere inviato in modo sincrono usando il SmtpClient classe send metodo. Invia il messaggio email specificato tramite un server SMTP per la consegna. Il mittente del messaggio, i destinatari, l’oggetto e il corpo del messaggio sono specificati usando oggetti String. Per inviare un messaggio email in modo sincrono, segui i passaggi indicati 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 SmtpClient classe send metodo e passa il MailMessage istanza.

Il seguente snippet di codice Java 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-Java

// 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.setHost("mail.server.com");
client.setUsername("username");
client.setPassword("password");
client.setPort(587);
client.setSecurityOptions(SecurityOptions.SSLExplicit);

try {
    // Client.Send will send this message
    client.send(msg);
    System.out.println("Message sent");
} catch (Exception ex) {
    System.err.println(ex);
}

Invio di Email in Asincrono

A volte potresti voler inviare email in modo asincrono. Per esempio, se invii molte email tramite la tua applicazione, l’approccio sincrono potrebbe non funzionare. In tal caso, puoi usare beginSend. Il beginSend metodo del SmtpClient classe invia un messaggio email a un server SMTP per la consegna. Questo metodo non blocca il thread chiamante e consente al chiamante di passare un oggetto al metodo che viene invocato al completamento dell’operazione. Per inviare un messaggio email Outlook in modo asincrono in Java, segui questi passaggi:

Crea un’istanza di MailMessage classe e utilizza le sue diverse proprietà.
Crea un’istanza di SmtpClient classe e specifica host, porta, nome utente e password.
Crea un’istanza definita dall’utente che verrà passata al metodo e invocata quando l’operazione asincrona termina.
Invia il messaggio usando beginSend metodo di SmtpClient classe e passa il MailMessage istanza e un’istanza definita dall’utente al suo interno insieme a una funzione di callback da chiamare quando l’operazione è completata.

Per ricevere una notifica quando l’email è stata inviata o l’operazione è stata annullata, la funzione di callback passata a beginSend method è chiamato. Dopo aver chiamato il SmtpClient classe beginSend method non è necessario attendere che un messaggio email sia inviato completamente. Possiamo chiamare un altro metodo beginSend allo stesso tempo. Quando un’email è stata inviata usando il beginSend metodo, il frammento di codice stampa un messaggio ("Message Sent"). Il seguente programma Java o frammento di codice mostra come inviare email in modo asincrono.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

public static void run() {
    sendMail();
}

static SmtpClient getSmtpClient() {
    SmtpClient client = new SmtpClient();
    client.setHost("mail.server.com");
    // Specify your mail Username, Password, Port # and security option
    client.setUsername("username");
    client.setPassword("password");
    client.setPort(587);
    client.setSecurityOptions(SecurityOptions.SSLExplicit);
    return client;
}

static void sendMail() {
    try {

        // Declare msg as MailMessage instance
        MailMessage msg = new MailMessage("sender@gmail.com", "receiver@gmail.com", "Test subject", "Test body");
        SmtpClient client = getSmtpClient();
        Object state = new Object();
        IAsyncResult ar = client.beginSend(msg, callback, state);
        // If the user canceled the send, and mail hasn't been sent yet,
        client.cancelAsyncOperation(ar);

        msg.dispose();
        System.out.println("Goodbye.");
    } catch (Exception ex) {
        System.err.println(ex);
    }
}

static AsyncCallback callback = new AsyncCallback() {
    public void invoke(IAsyncResult ar) {
        IAsyncResultExt task = null;
        if (ar instanceof IAsyncResult)
            task = (IAsyncResultExt) ar;

        if (task != null && task.isCanceled()) {
            System.out.println("Send canceled.");
        }

        if (task != null && task.getErrorInfo() != null) {
            System.out.println(task.getErrorInfo());
        } else {
            System.out.println("Message Sent.");
        }
    }
};

Invio di messaggi memorizzati dal disco

I file EML (file di posta elettronica di Outlook Express) contengono un’intestazione email, il corpo del messaggio e eventuali allegati. Aspose.Email consente agli sviluppatori di lavorare con i file EML in diversi modi. Questo articolo mostra come caricare i file EML dal disco e inviarli come email con SMTP. È possibile caricare file .eml dal disco o dallo stream in 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 Java mostra come inviare messaggi memorizzati dal disco.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Load an EML file in MailMessage class
MailMessage message = MailMessage.load(dataDir + "test.eml");

// Send this message using SmtpClient
SmtpClient client = new SmtpClient("host", "username", "password");

try {
    client.send(message);
} catch (Exception ex) {
    System.out.println(ex.getMessage());
}

Invio di email in testo semplice

Gli esempi di programmazione di seguito mostrano come inviare un messaggio 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-Java

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

// Set From field, To field and Plain text body
message.setFrom(MailAddress.to_MailAddress("sender@sender.com"));
message.getTo().add("receiver@receiver.com");
message.setBody("This is Plain Text Body");

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

// And Specify your mailing host server, Username, Password and Port
client.setHost("smtp.server.com");
client.setUsername("Username");
client.setPassword("Password");
client.setPort(25);

try {
    // Client.Send will send this message
    client.send(message);
    System.out.println("Message sent");
} catch (Exception ex) {
    System.err.println(ex);
}

Invio di 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 send metodo.

Per gli scopi di questo articolo, il contenuto HTML dell’email è rudimentale: Questo è il corpo HTML La maggior parte delle email HTML sarà più complessa. Il seguente frammento di programma Java mostra come inviare un’email con corpo HTML.

public static void run() {
    // Declare msg as MailMessage instance
    MailMessage msg = new MailMessage();

    // Use MailMessage properties like specify sender, recipient, message and HtmlBody
    msg.setFrom(MailAddress.to_MailAddress("newcustomeronnet@gmail.com"));
    msg.setTo(MailAddressCollection.to_MailAddressCollection("asposetest123@gmail.com"));
    msg.setSubject("Test subject");
    msg.setHtmlBody("<html><body>This is the HTML body</body></html>");
    SmtpClient client = getSmtpClient();
    try {
        // Client will send this message
        client.send(msg);
        System.out.println("Message sent");
    } catch (Exception ex) {
        System.err.println(ex);
    }

    System.out.println("Email sent with HTML body.");
}

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

Invio di email con testo alternativo del messaggio

Gli esempi di programmazione di seguito mostrano come inviare un semplice messaggio email HTML con contenuto 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 send 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-Java

// Declare message as MailMessage instance
MailMessage message = new MailMessage();

// Creates AlternateView to view an email message using the content specified in the //String
AlternateView alternate = AlternateView.createAlternateViewFromString("Alternate Text");

// Adding alternate text
message.getAlternateViews().addItem(alternate);

Invio di email in blocco

Inviare email in blocco significa inviare un lotto di email in un unico messaggio. Possiamo inviare un lotto di email usando la di SmtpClient classe send sovraccarico del metodo che accetta un MailMessageCollection classe:

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 send 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-Java

// Create SmtpClient as client and specify server, port, user name and password
SmtpClient client = new SmtpClient("mail.server.com", 25, "Username", "Password");

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

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

// Use client.BulkSend function to complete the bulk send task
try {
    // Send Message using BulkSend method
    client.send(manyMsg);
    System.out.println("Message sent");
} catch (Exception ex) {
    System.err.println(ex);
}

Ottieni informazioni sui messaggi inviati in blocco

Quando invii messaggi in blocco, puoi ottenere informazioni sul numero di messaggi inviati con successo e l’elenco di questi messaggi. Il SucceededSending l’evento è utilizzato a questo scopo.

Il campione di codice sottostante mostra come ottenere informazioni sul numero di messaggi inviati con successo:

try (SmtpClient client = new SmtpClient(host, SecurityOptions.Auto)) {
    final AtomicInteger messageCount = new AtomicInteger(0);

    client.setSucceededSending(new EventHandler<MailMessageEventArgs>() {
        public void invoke(Object sender, MailMessageEventArgs eventArgs) {
            System.out.println("The message " + eventArgs.getMessage().getSubject() + " was successfully sent.");
            messageCount.incrementAndGet();
        }
    });

    client.send(messages);

    System.out.println(messageCount + " messages were successfully sent.");
}

Invio di email con MultiConnection

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

SmtpClient smtpClient = new SmtpClient();
smtpClient.setHost("<HOST>");
smtpClient.setUsername("<USERNAME>");
smtpClient.setPassword("<PASSWORD>");
smtpClient.setPort(587);
smtpClient.setSupportedEncryption(EncryptionProtocols.Tls);
smtpClient.setSecurityOptions(SecurityOptions.SSLExplicit);

List<MailMessage> messages = new ArrayList<MailMessage>();
for (int i = 0; i < 20; i++) {
    MailMessage message = new MailMessage("<EMAIL ADDRESS>", "<EMAIL ADDRESS>", "Test Message - " + UUID.randomUUID().toString(),
            "SMTP Send Messages with MultiConnection");
    messages.add(message);
}

smtpClient.setConnectionsQuantity(5);
smtpClient.setUseMultiConnection(MultiConnectionMode.Enable);
smtpClient.send(messages);

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

Invio di un Messaggio come TNEF

Le email TNEF hanno una formattazione speciale che può andare persa se inviate usando l’API standard. Aspose.Email fornisce la capacità di inviare email come TNEF, preservando così il formato. 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.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

String emlFileName = dataDir + "Message.eml"; // A TNEF Email

// Load from eml
MailMessage eml1 = MailMessage.load(emlFileName, new EmlLoadOptions());
eml1.setFrom(MailAddress.to_MailAddress("somename@gmail.com"));
eml1.getTo().clear();
eml1.getTo().addItem(new MailAddress("first.last@test.com"));
eml1.setSubject("With PreserveTnef flag during loading");
eml1.setDate(new Date());
SmtpClient client = new SmtpClient("smtp.gmail.com", 587, "somename", "password");
client.setSecurityOptions(SecurityOptions.Auto);
client.setUseTnef(true); // Use this flag to send as TNEF
client.send(eml1);

Invio di richieste di riunione

Microsoft Outlook offre funzioni di calendario così come la gestione delle email. Quando un utente apre un’email con un invito a un evento, Outlook gli chiede di accettare o rifiutare l’invito. Aspose.Email consente agli sviluppatori di aggiungere funzioni di calendario alle tue email.

Invio di 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.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

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

// Set the sender, recipient, who will receive the meeting request. Basically, the recipient is the same as the meeting attendees
msg.setFrom(MailAddress.to_MailAddress("newcustomeronnet@gmail.com"));
msg.setTo(MailAddressCollection.to_MailAddressCollection("person1@domain.com, person2@domain.com, person3@domain.com, asposetest123@gmail.com"));

// Create Appointment instance
Calendar cal = Calendar.getInstance();
cal.set(2015, Calendar.JULY, 17, 13, 0, 0);
Date startDate = cal.getTime();
cal.set(2015, Calendar.JULY, 17, 14, 0, 0);
Date endDate = cal.getTime();
Appointment app = new Appointment("Room 112", startDate, endDate, msg.getFrom(), msg.getTo());
app.setSummary("Release Meetting");
app.setDescription("Discuss for the next release");

// Add appointment to the message and Create an instance of SmtpClient class
msg.addAlternateView(app.requestApointment());
SmtpClient client = getSmtpClient();

try {
    // Client.Send will send this message
    client.send(msg);
    System.out.println("Message sent");
} catch (Exception ex) {
    System.err.println(ex);
}

Supporto iCalendar per IBM Lotus Notes

La funzionalità calendario di Aspose.Email si basa sullo standard iCalendar, uno standard per lo scambio di dati di calendario (RFC 2445 o Riferimento Sintassi RFC2445). Pertanto, supporta non solo Microsoft Outlook ma anche IBM Lotus Notes. Per inviare una richiesta di riunione in Lotus Notes, segui gli stessi passaggi indicati sopra.

Inoltra un’Email usando SMTP Client

Inoltro Email con client SMTP

Inoltrare un’email è una pratica comune nella comunicazione digitale quotidiana. Un’email ricevuta può essere inoltrata a destinatari specifici senza condividere con i mittenti originali. Aspose.Email API SmtpClient fornisce la capacità di inoltrare un’email a destinatari specifici. Il suo Inoltra metodo può essere usato per inoltrare un’email ricevuta o salvata ai destinatari desiderati come mostrato in questo articolo. Il seguente snippet di codice mostra come inoltrare un’email usando SMTP Client.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

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

// Specify your mailing host server, Username, Password, Port and SecurityOptions
client.setHost("mail.server.com");
client.setUsername("username");
client.setPassword("password");
client.setPort(587);
client.setSecurityOptions(SecurityOptions.SSLExplicit);
MailMessage message = MailMessage.load(dataDir + "Message.eml");
client.forward("Recipient1@domain.com", "Recipient2@domain.com", message);

Inoltro Email senza usare 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.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

String host = "mail.server.com";
String username = "username";
String password = "password";
int smtpPort = 587;
String sender = "Sender@domain.com";
MailAddressCollection recipients = new MailAddressCollection();
recipients.add("recepient1@domain.com, recepient2@domain.com");

try (SmtpClient client = new SmtpClient(host, smtpPort, username, password, SecurityOptions.Auto)) {
    String fileName = "test.eml";
    try (FileInputStream fs = new FileInputStream(new File(dataDir + fileName))) {
        client.forward(sender, recipients, fs);
    }
}

Eseguire la Fusione di Stampa

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 di DataTable classe.
Aggiungi le colonne Receipt, FirstName e LastName come fonti di dati nel DataTable classe.
Crea un’istanza di DataRow classe.
Specifica l’indirizzo di ricezione, nome e cognome nel DataRow oggetto.
Crea un’istanza di MailMessageCollection classe
Specificare il TemplateEngine e DataTable istanze nel MailMessageCollection istanza.
Crea un’istanza di SmtpClient classe e specifica server, porta, nome utente e password.
Invia email usando il SmtpClient classe send metodo.

Nel campione sotto, #FirstName# indica un DataTable colonna, il cui valore è impostato dall’utente. Il seguente snippet di codice mostra come eseguire la Mail Merge.

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

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

    // Add subject and from address
    msg.setSubject("Hello, #FirstName#");
    msg.setFrom(MailAddress.to_MailAddress("sender@sender.com"));

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

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

    msg.setHtmlBody(htmlBody);

    // 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", new TemplateRoutine() {
        public Object invoke(Object[] args) {
            return getSignature(args);
        }
    });

    // Create an instance of DataTable and Fill a DataTable as data source
    DataTable dt = new DataTable();
    dt.getColumns().add("Receipt");
    dt.getColumns().add("FirstName");
    dt.getColumns().add("LastName");

    DataRow dr;
    dr = dt.newRow();
    dr.set("Receipt", "Nancy&lt;Nancy@somedomain.com&gt;");
    dr.set("FirstName", "Nancy");
    dr.set("LastName", "Doe");
    dt.getRows().add(dr);
    dr = dt.newRow();
    dr.set("Receipt", "Andrew&lt;Andrew@somedomain.com&gt;");
    dr.set("FirstName", "Andrew");
    dr.set("LastName", "Doe");
    dt.getRows().add(dr);
    dr = dt.newRow();
    dr.set("Receipt", "Janet&lt;Janet@somedomain.com&gt;");
    dr.set("FirstName", "Janet");
    dr.set("LastName", "Doe");
    dt.getRows().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.setSecurityOptions(SecurityOptions.Auto);

        // Send messages in bulk
        client.send(messages);
    } catch (MailException ex) {
        System.err.println(ex);
    }

    catch (SmtpException ex) {
        System.err.println(ex);
    }

    System.out.println("Message sent after performing mail merge.");
}

// Template routine to provide signature
static Object getSignature(Object[] args) {
    return "Aspose.Email Team<br>Aspose Ltd.<br>" + new Date().toString();
}

Eseguire Unione Mail Riga per Riga

L’utente può unire anche righe di dati individuali per ottenere un completo e preparato MailMessage oggetto. Il TemplateEngine.merge metodo può essere usato per eseguire un’unione mail riga per riga.

// Create message from the data in current row.
MailMessage message = engine.merge(currentRow);

Connessione al Server SMTP Funzionalità Utilitarie - Client SMTP