Creación y Guardado de Archivos MSG
Aspose.Email admite la creación de archivos de mensaje de Outlook (MSG). Este artículo explica cómo:
- Crear mensajes MSG.
- Crear mensajes MSG con archivos adjuntos.
- Crear un mensaje MSG con un cuerpo RTF.
- Guardar un mensaje como borrador.
- Trabajar con la compresión del cuerpo.
Creación y Guardado de Mensajes de Outlook
La clase MailMessage tiene el método Save() que puede guardar archivos MSG de Outlook en el disco o en un flujo. Los fragmentos de código a continuación crean una instancia de la clase MailMessage, establecen propiedades como de, para, asunto y cuerpo. El método Save() toma el nombre del archivo como argumento. Además, los mensajes de Outlook pueden ser creados con un cuerpo RTF comprimido utilizando las MapiConversionOptions. Para configurar, crea una nueva aplicación de Windows y agrega una referencia al dll de Aspose.Email en el proyecto.
- Crea una nueva instancia de la clase MailMessage y establece las propiedades From, To, Subject y Body.
- Llama al método FromMailMessage de la clase MapiMessage que acepta el objeto del tipo MailMessage. El método FromMailMessage convierte el MailMessage en un MapiMessage (MSG).
- Llama al método MapiMessage.Save() para guardar el archivo MSG.
Escribe el siguiente código en el evento click del control del botón de la aplicación de Windows.
// 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 | |
MailMessage mailMsg = new MailMessage(); | |
// Set from, to, subject and body properties | |
mailMsg.From = "sender@domain.com"; | |
mailMsg.To = "receiver@domain.com"; | |
mailMsg.Subject = "This is test message"; | |
mailMsg.Body = "This is test body"; | |
// Create an instance of the MapiMessage class and pass MailMessage as argument | |
MapiMessage outlookMsg = MapiMessage.FromMailMessage(mailMsg); | |
// Save the message (MSG) file | |
string strMsgFile = @"CreatingAndSavingOutlookMessages_out.msg"; | |
outlookMsg.Save(dataDir + strMsgFile); |
Creación de Archivos MSG con Archivos Adjuntos
En el ejemplo anterior, creamos un archivo MSG simple. Aspose.Email también admite guardar archivos de mensajes con archivos adjuntos. Todo lo que necesitas hacer es agregar los archivos adjuntos a la instancia de MailMessage. Agrega archivos adjuntos llamando al método Add() sobre la colección MailMessage.Attachments. Agrega un cuadro de lista al formulario creado anteriormente y dos botones, uno para agregar y otro para eliminar archivos adjuntos. La aplicación que agrega archivos adjuntos funciona así:
- Cuando se hace clic en el botón Agregar Archivo Adjunto, se muestra un Diálogo para Abrir Archivo para ayudar a los usuarios a navegar y seleccionar el archivo adjunto.
- Cuando se ha seleccionado un archivo, la ruta completa se agrega a una lista.
- Cuando se crea el archivo MSG, las rutas de los archivos adjuntos se obtienen de la lista y se agregan a la colección MailMessage.Attachments.
Escribe el siguiente código en el evento click del botón Agregar Archivo Adjunto.
// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET | |
// Open a file open dialog to select the attachment | |
OpenFileDialog fd = new OpenFileDialog(); | |
// If user selected the file and clicked OK, add the file name and path to the list | |
if (fd.ShowDialog() == DialogResult.OK) | |
{ | |
lstAttachments.Items.Add(fd.FileName); | |
} |
Cuando se hace clic en el botón Eliminar Archivo Adjunto, elimina los elementos seleccionados de la lista. Escribe el siguiente código en el evento click del botón Eliminar Archivo Adjunto.
// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET | |
// Check if the user has selected any item in the attachments listbox | |
if (lstAttachments.SelectedItems.Count > 0) | |
{ | |
// Remove the selected attachment from the listbox | |
lstAttachments.Items.RemoveAt(lstAttachments.SelectedIndex); | |
} |
Agrega el código para añadir los archivos adjuntos a la instancia de MailMessage. El código final para la función Write Msg está escrito como se muestra a continuación.
// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET | |
// File name for output MSG file | |
string strMsgFile; | |
// Open a save file dialog for saving the file and Add filter for msg files | |
SaveFileDialog fd = new SaveFileDialog(); | |
fd.Filter = "Outlook Message files (*.msg)|*.msg|All files (*.*)|*.*"; | |
// If user pressed OK, save the file name + path | |
if (fd.ShowDialog() == DialogResult.OK) | |
{ | |
strMsgFile = fd.FileName; | |
} | |
else | |
{ | |
// If user did not selected the file, return | |
return; | |
} | |
// Create an instance of MailMessage class | |
MailMessage mailMsg = new MailMessage(); | |
// Set from, to, subject and body properties | |
mailMsg.From = txtFrom.Text; | |
mailMsg.To = txtTo.Text; | |
mailMsg.Subject = txtSubject.Text; | |
mailMsg.Body = txtBody.Text; | |
// Add the attachments | |
foreach (string strFileName in lstAttachments.Items) | |
{ | |
mailMsg.Attachments.Add(new Attachment(strFileName)); | |
} | |
// Create an instance of MapiMessage class and pass MailMessage as argument | |
MapiMessage outlookMsg = MapiMessage.FromMailMessage(mailMsg); | |
outlookMsg.Save(strMsgFile); |
Creación de Archivos MSG con Cuerpo RTF
También puedes crear archivos de Mensaje de Outlook (MSG) con cuerpos de texto enriquecido (RTF) con Aspose.Email. El cuerpo RTF admite el formato de texto. Crea uno estableciendo la propiedad MailMessage.HtmlBody. Cuando conviertes una instancia de MailMessage en una instancia de MapiMessage, el cuerpo HTML se convierte en RTF. De esta manera, se conserva el formato del cuerpo del correo electrónico.
El siguiente ejemplo crea un archivo MSG con un cuerpo RTF. Hay un encabezado, formato en negrita y subrayado aplicado en el cuerpo HTML. Este formato se mantiene cuando el HTML se convierte en RTF.
// 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 | |
MailMessage mailMsg = new MailMessage(); | |
// Set from, to, subject and body properties | |
mailMsg.From = "from@domain.com"; | |
mailMsg.To = "to@domain.com"; | |
mailMsg.Subject = "subject"; | |
mailMsg.HtmlBody = "<h3>rtf example</h3><p>creating an <b><u>outlook message (msg)</u></b> file using Aspose.Email.</p>"; | |
MapiMessage outlookMsg = MapiMessage.FromMailMessage(mailMsg); | |
outlookMsg.Save(dataDir + "CreatingMSGFilesWithRTFBody_out.msg"); |
Guardando Mensajes en Estado de Borrador
Los correos electrónicos se guardan como borradores cuando alguien ha comenzado a editarlos pero quiere volver a ellos para completarlos más tarde. Aspose.Email admite el guardado de mensajes de correo electrónico en estado de borrador estableciendo una bandera de mensaje. A continuación se muestra un código de ejemplo para guardar un mensaje de correo electrónico de Outlook (MSG) como borrador.
// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET | |
// Change properties of an existing MSG file | |
string strExistingMsg = @"message.msg"; | |
// Load the existing file in MailMessage and Change the properties | |
MailMessage msg = MailMessage.Load(dataDir + strExistingMsg, new MsgLoadOptions()); | |
msg.Subject += "NEW SUBJECT (updated by Aspose.Email)"; | |
msg.HtmlBody += "NEW BODY (udpated by Aspose.Email)"; | |
// Create an instance of type MapiMessage from MailMessage, Set message flag to un-sent (draft status) and Save it | |
MapiMessage mapiMsg = MapiMessage.FromMailMessage(msg); | |
mapiMsg.SetMessageFlags(MapiMessageFlags.MSGFLAG_UNSENT); | |
mapiMsg.Save(dataDir + "SavingMessageInDraftStatus_out.msg"); |
Compresión RTF al establecer el cuerpo del mensaje MAPI
NOTA: El proceso de compresión puede ralentizar el rendimiento al crear mensajes. Al comprender este hecho y configurar la bandera de compresión según requisitos específicos y el compromiso entre el tamaño del archivo y el rendimiento, los desarrolladores pueden gestionar eficazmente la creación de archivos MSG y PST al tratar con mensajes de correo electrónico.
En esta sección aprenderás a utilizar la compresión RTF al establecer el cuerpo del mensaje MAPI. La compresión RTF está destinada a reducir el tamaño de un mensaje así como los archivos PST (Tabla de Almacenamiento Personal) resultantes que Microsoft Outlook utiliza para almacenar mensajes de correo electrónico y otros datos. Al utilizar la compresión RTF al configurar el cuerpo del mensaje, los desarrolladores pueden reducir la cantidad de memoria necesaria para almacenar mensajes de correo electrónico u optimizar el ancho de banda de la red al transmitir mensajes.
Para ello, se han diseñado dos métodos sobrecargados:
-
MapiMessageItemBase.SetBodyContent(string content, BodyContentType contentType, bool compression): Este método permite establecer el contenido del cuerpo del mensaje utilizando el contenido de cadena especificado y especificando el tipo de contenido del cuerpo (por ejemplo, texto plano, HTML, etc.). El parámetro opcional de compresión es un valor que especifica si el contenido debe ser comprimido utilizando compresión RTF. Si el parámetro de compresión es verdadero, el contenido será comprimido, resultando en un tamaño de mensaje más pequeño.
-
MapiMessageItemBase.SetBodyRtf(string content, bool compression): Este método establece específicamente el contenido del cuerpo del mensaje en formato RTF. El parámetro de contenido es una cadena que representa el contenido RTF que se establecerá como el cuerpo del mensaje. Como en el método anterior, el parámetro de compresión determina si se debe aplicar compresión RTF al contenido. Si la compresión es verdadera, el contenido RTF será comprimido para reducir el tamaño.
El siguiente ejemplo de código muestra cómo establecer el cuerpo HTML y mantenerlo comprimido:
var msg = new MapiMessage("from@doamin.com", "to@domain.com", "subject", "body");
// establecer el cuerpo html y mantenerlo comprimido
// esto reducirá el tamaño del mensaje
msg.SetBodyContent(htmlBody, BodyContentType.Html, true);
También hay una propiedad MapiConversionOptions.UseBodyCompression. Cuando esta propiedad está habilitada, se aplica compresión del cuerpo RTF durante la conversión de MailMessage a MapiMessage, resultando en un tamaño de archivo MSG más pequeño. Se muestra en el siguiente ejemplo de código:
var message = MailMessage.Load(fileName);
var options = new MapiConversionOptions();
options.UseBodyCompression = true;
var msg = MapiMessage.FromMailMessage(message, options);