Cargando y Guardando Mensajes

Cargando y Guardando Mensajes

Detección de Formatos de Archivos

La API de Aspose.Email proporciona la capacidad de detectar el formato de archivo del archivo de mensaje proporcionado. El método DetectFileFormat de la clase FileFormatUtil se puede utilizar para lograr esto. Las siguientes clases y métodos se pueden utilizar para detectar el formato de archivo cargado.

El siguiente fragmento de código le muestra cómo detectar formatos de archivo.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// The path to the File directory.
string dataDir = RunExamples.GetDataDir_Email();
// Detect file format and Gets the detected load format
FileFormatInfo info = FileFormatUtil.DetectFileFormat(dataDir + "message.msg");
Console.WriteLine("The message format is: " + info.FileFormatType);

Cargando un Mensaje con Opciones de Carga

El siguiente fragmento de código le muestra cómo cargar un mensaje con opciones de carga.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// The path to the File directory.
string dataDir = RunExamples.GetDataDir_Email();
// Load Eml, html, mhtml, msg and dat file
MailMessage mailMessage = MailMessage.Load(dataDir + "Message.eml", new EmlLoadOptions());
MailMessage.Load(dataDir + "description.html", new HtmlLoadOptions());
MailMessage.Load(dataDir + "Message.mhtml", new MhtmlLoadOptions());
MailMessage.Load(dataDir + "Message.msg", new MsgLoadOptions());
// loading with custom options
EmlLoadOptions emlLoadOptions = new EmlLoadOptions
{
PrefferedTextEncoding = Encoding.UTF8,
PreserveTnefAttachments = true
};
MailMessage.Load(dataDir + "description.html", emlLoadOptions);
HtmlLoadOptions htmlLoadOptions = new HtmlLoadOptions
{
PrefferedTextEncoding = Encoding.UTF8,
ShouldAddPlainTextView = true,
PathToResources = dataDir
};
MailMessage.Load(dataDir + "description.html", emlLoadOptions);

Preservando el Formato del Mensaje Embebido Durante la Carga

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
string dataDir = RunExamples.GetDataDir_Email();
MailMessage mail = MailMessage.Load(dataDir + "tnefWithMsgInside.eml", new EmlLoadOptions() { PreserveEmbeddedMessageFormat = true });
FileFormatType fileFormat = FileFormatUtil.DetectFileFormat(mail.Attachments[0].ContentStream).FileFormatType;
Console.WriteLine("Embedded message file format: " + fileFormat);

Cargando un Mensaje Preservando o Eliminando una Firma

La preservación de la firma está soportada por defecto al cargar archivos EML. Para eliminar la firma, puede establecer la propiedad LoadOptions.RemoveSignature en true.

El siguiente ejemplo de código muestra cómo eliminar una firma al cargar un mensaje:

var msg = MapiMessage.Load(fileName, new EmlLoadOptions() { RemoveSignature = true});

Comprobando la Firma de Correos Electrónicos Seguros

La clase SecureEmailManager le permite comprobar la firma de objetos MailMessage seguros.

La clase SmimeResult almacena los resultados de la verificación.

Los siguientes métodos de la clase SecureEmailManager y un fragmento de código le permitirán procesar una firma:

var eml = MailMessage.Load(fileName);
var result = new SecureEmailManager().CheckSignature(eml);

var certFileName = "cert.pfx";
var cert = new X509Certificate2(certFileName, "pass");
var eml = MailMessage.Load(fileName);
var store = new X509Store();
store.Open(OpenFlags.ReadWrite);
store.Add(cert);
store.Close();

var result = new SecureEmailManager().CheckSignature(eml, cert, store);

Guardando y Convirtiendo Mensajes

Aspose.Email facilita la conversión de cualquier tipo de mensaje a otro formato. Para demostrar esta característica, el código en este artículo carga tres tipos de mensajes desde el disco y los guarda en otros formatos. La clase base SaveOptions y las clases EmlSaveOptions, MsgSaveOptions, MhtSaveOptions, HtmlSaveOptions para configuraciones adicionales al guardar MailMessage se pueden utilizar para guardar mensajes en otros formatos. El artículo muestra cómo usar estas clases para guardar un correo electrónico de ejemplo como:

  • Formato EML.
  • Outlook MSG.
  • Formato MHTML.
  • Formato HTML.

Cargar y Guardar un mensaje EML

El siguiente fragmento de código le muestra cómo cargar un mensaje EML y guardarlo en el disco en el mismo formato.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// The path to the File directory.
string dataDir = RunExamples.GetDataDir_Email();
// Initialize and Load an existing EML file by specifying the MessageFormat
MailMessage mailMessage = MailMessage.Load(dataDir + "Attachments.eml");
mailMessage.Save(dataDir + "LoadAndSaveFileAsEML_out.eml", SaveOptions.DefaultEml);

Cargar y Guardar un mensaje EML Preservando los Límites Originales

El siguiente fragmento de código le muestra cómo cargar EML y guardar como EML preservando los límites originales.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// The path to the File directory.
string dataDir = RunExamples.GetDataDir_Email();
MailMessage mailMessage = MailMessage.Load(dataDir + "Attachments.eml");
// Save as eml with preserved original boundares
EmlSaveOptions emlSaveOptions = new EmlSaveOptions(MailMessageSaveType.EmlFormat)
{
PreserveOriginalBoundaries = true
};
mailMessage.Save(dataDir + "PreserveOriginalBoundaries_out.eml", emlSaveOptions);

Guardando como EML Preservando Archivos Adjuntos TNEF

El siguiente fragmento de código muestra cómo guardar como EML preservando los archivos adjuntos TNEF.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// The path to the File directory.
string dataDir = RunExamples.GetDataDir_Email();
MailMessage mailMessage = MailMessage.Load(dataDir + "PreserveOriginalBoundaries.eml");
// Save as eml with preserved attachment
EmlSaveOptions emlSaveOptions = new EmlSaveOptions(MailMessageSaveType.EmlFormat)
{
FileCompatibilityMode = FileCompatibilityMode.PreserveTnefAttachments
};
mailMessage.Save(dataDir + "PreserveTNEFAttachment_out.eml", emlSaveOptions);

Guardar EML como MSG

El siguiente fragmento de código le muestra cómo cargar un mensaje EML y convertirlo a MSG utilizando la opción apropiada de SaveOptions.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Data directory for reading and writing files
string dataDir = RunExamples.GetDataDir_Email();
// Initialize and Load an existing EML file by specifying the MessageFormat
MailMessage eml = MailMessage.Load(dataDir + "Message.eml");
// Save the Email message to disk in ASCII format and Unicode format
eml.Save(dataDir + "AnEmail_out.msg", SaveOptions.DefaultMsgUnicode);

Guardando como MSG con Fechas Preservadas

La clase MsgSaveOptions le permite guardar el mensaje fuente como un archivo de Mensaje de Outlook (MSG) preservando las fechas. El siguiente fragmento de código le muestra cómo guardar como MSG con fechas preservadas.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Data directory for reading and writing files
string dataDir = RunExamples.GetDataDir_Email();
// Initialize and Load an existing EML file by specifying the MessageFormat
MailMessage eml = MailMessage.Load(dataDir + "Message.eml");
// Save as msg with preserved dates
MsgSaveOptions msgSaveOptions = new MsgSaveOptions(MailMessageSaveType.OutlookMessageFormatUnicode)
{
PreserveOriginalDates = true
};
eml.Save(Path.Combine(dataDir, "outTest_out.msg"), msgSaveOptions);

Guardando MailMessage como MHTML

Diferentes opciones de MHTML se pueden usar para obtener los resultados deseados. El siguiente fragmento de código le muestra cómo cargar un mensaje EML en MailMessage y convertirlo a MHTML con una fecha de mensaje en el sistema UTC.

// Para ejemplos completos y archivos de datos, por favor visite https://github.com/aspose-email/Aspose.Email-for-.NET

// Establecer opciones para la salida MHTML
MhtSaveOptions saveOptions = SaveOptions.DefaultMhtml;
saveOptions.PreserveOriginalDate = false; // guardar la fecha de un mensaje como fecha UTC

// Inicializar y cargar un archivo EML existente
using (MailMessage mailMessage = MailMessage.Load(folderPath + "Message.eml"))
{
    mailMessage.Save(folderPath + "Message_out.mhtml", saveOptions);
}

Convertir a MHTML con Configuraciones Opcionales

La clase MhtSaveOptions proporciona opciones adicionales para guardar mensajes de correo electrónico en formato MHTML. El enumerador MhtFormatOptions hace posible escribir información adicional de correo electrónico en el MHTML de salida. Los siguientes campos adicionales pueden ser escritos:

  • WriteHeader – escribir el encabezado del correo electrónico en el archivo de salida.
  • WriteOutlineAttachments – escribir archivos adjuntos de esquema en el archivo de salida.
  • WriteCompleteEmailAddress – escribir la dirección de correo electrónico completa en el archivo de salida.
  • NoEncodeCharacters – no se debe utilizar codificación de transferencia de caracteres.
  • HideExtraPrintHeader – ocultar el encabezado de impresión extra de la parte superior del archivo de salida.
  • WriteCompleteToEmailAddress – escribir la dirección de correo electrónico completa del destinatario en el archivo de salida.
  • WriteCompleteFromEmailAddress – escribir la dirección de correo electrónico completa del remitente en el archivo de salida.
  • WriteCompleteCcEmailAddress – escribir las direcciones de correo electrónico completas de los destinatarios en copia en el archivo de salida.
  • WriteCompleteBccEmailAddress – escribir la dirección de correo electrónico completa de los destinatarios en copia oculta en el archivo de salida.
  • RenderCalendarEvent – escribir texto del evento de calendario en el archivo de salida.
  • SkipByteOrderMarkInBody – escribir los bytes del Byte Order Mark (BOM) en el archivo de salida.
  • RenderVCardInfo – escribir texto de VCard AlternativeView en el archivo de salida.
  • DisplayAsOutlook – mostrar el encabezado From.
  • RenderTaskFields – escribir campos específicos de tarea en el archivo de salida.
  • None – No se especificó ninguna configuración.

El siguiente fragmento de código muestra cómo convertir archivos EML a MHTML con configuraciones opcionales.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
MailMessage eml = MailMessage.Load(Path.Combine(dataDir, "Message.eml"));
// Save as mht with header
MhtSaveOptions mhtSaveOptions = new MhtSaveOptions
{
//Specify formatting options required
//Here we are specifying to write header informations to outpu without writing extra print header
//and the output headers should display as the original headers in message
MhtFormatOptions = MhtFormatOptions.WriteHeader | MhtFormatOptions.HideExtraPrintHeader | MhtFormatOptions.DisplayAsOutlook,
// Check the body encoding for validity.
CheckBodyContentEncoding = true
};
eml.Save(Path.Combine(dataDir, "outMessage_out.mht"), mhtSaveOptions);

Renderizando Eventos de Calendario al Convertir a MHTML

El MhtFormatOptions.RenderCalendarEvent renderiza los eventos de Calendario a la salida MTHML. El siguiente fragmento de código le muestra cómo renderizar eventos de calendario al convertir a MHTML.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// The path to the File directory.
string dataDir = RunExamples.GetDataDir_Email();
string fileName = "Meeting with Recurring Occurrences.msg";
MailMessage msg = MailMessage.Load(dataDir + fileName);
MhtSaveOptions options = new MhtSaveOptions();
{
options.MhtFormatOptions = MhtFormatOptions.WriteHeader | MhtFormatOptions.RenderCalendarEvent;
//Format the output details if required - optional
//Set the display for Start Property
if (options.FormatTemplates.ContainsKey(MhtTemplateName.Start))
options.FormatTemplates[MhtTemplateName.Start] = @"<span class='headerLineTitle'>Start:</span><span class='headerLineText'>{0}</span><br/>";
else
options.FormatTemplates.Add(MhtTemplateName.Start, @"<span class='headerLineTitle'>Start:</span><span class='headerLineText'>{0}</span><br/>");
//Set the display for End Property
if (options.FormatTemplates.ContainsKey(MhtTemplateName.End))
options.FormatTemplates[MhtTemplateName.End] = @"<span class='headerLineTitle'>End:</span><span class='headerLineText'>{0}</span><br/>";
else
options.FormatTemplates.Add(MhtTemplateName.End, @"<span class='headerLineTitle'>End:</span><span class='headerLineText'>{0}</span><br/>");
//Set the display for Recurrence Property
if (options.FormatTemplates.ContainsKey(MhtTemplateName.Recurrence))
options.FormatTemplates[MhtTemplateName.Recurrence] = @"<span class='headerLineTitle'>Recurrence:</span><span class='headerLineText'>{0}</span><br/>";
else
options.FormatTemplates.Add(MhtTemplateName.Recurrence, @"<span class='headerLineTitle'>Recurrence:</span><span class='headerLineText'>{0}</span><br/>");
//Set the display for RecurrencePattern Property
if (options.FormatTemplates.ContainsKey(MhtTemplateName.RecurrencePattern))
options.FormatTemplates[MhtTemplateName.RecurrencePattern] = @"<span class='headerLineTitle'>RecurrencePattern:</span><span class='headerLineText'>{0}</span><br/>";
else
options.FormatTemplates.Add(MhtTemplateName.RecurrencePattern, @"<span class='headerLineTitle'>RecurrencePattern:</span><span class='headerLineText'>{0}</span><br/>");
//Set the display for Organizer Property
if (options.FormatTemplates.ContainsKey(MhtTemplateName.Organizer))
options.FormatTemplates[MhtTemplateName.Organizer] = @"<span class='headerLineTitle'>Organizer:</span><span class='headerLineText'>{0}</span><br/>";
else
options.FormatTemplates.Add(MhtTemplateName.Organizer, @"<span class='headerLineTitle'>Organizer:</span><span class='headerLineText'>{0}</span><br/>");
//Set the display for RequiredAttendees Property
if (options.FormatTemplates.ContainsKey(MhtTemplateName.RequiredAttendees))
options.FormatTemplates[MhtTemplateName.RequiredAttendees] = @"<span class='headerLineTitle'>RequiredAttendees:</span><span class='headerLineText'>{0}</span><br/>";
else
options.FormatTemplates.Add(MhtTemplateName.RequiredAttendees, @"<span class='headerLineTitle'>RequiredAttendees:</span><span class='headerLineText'>{0}</span><br/>");
};
msg.Save(dataDir + "Meeting with Recurring Occurrences.mhtml", options);

Exportando Correo Electrónico a MHT sin Imágenes Integradas

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
mhtSaveOptions.SkipInlineImages = true;
eml.Save(Path.Combine(dataDir, "EmlToMhtmlWithoutInlineImages_out.mht"), mhtSaveOptions);

Exportando Correo Electrónico a MHT con Zona Horaria Personalizada

La clase MailMessage proporciona la propiedad TimeZoneOffset para establecer una zona horaria personalizada al exportar a MHT. El siguiente fragmento de código le muestra cómo exportar correo electrónico a MHT con zona horaria personalizada.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
MailMessage eml = MailMessage.Load(dataDir + "Message.eml");
// Set the local time for message date.
eml.TimeZoneOffset = TimeZone.CurrentTimeZone.GetUtcOffset(DateTime.Now);
// or set custom time zone offset for message date (-0800)
// eml.TimeZoneOffset = new TimeSpan(-8,0,0);
// The dates will be rendered by local system time zone.
MhtSaveOptions so = new MhtSaveOptions();
so.MhtFormatOptions = MhtFormatOptions.WriteHeader;
eml.Save(dataDir + "ExportEmailToMHTWithCustomTimezone_out.mhtml", so);

Cambiando la Fuente al Convertir a MHT

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
string dataDir = RunExamples.GetDataDir_Email();
MailMessage eml = MailMessage.Load(dataDir + "Message.eml");
MhtSaveOptions options = SaveOptions.DefaultMhtml;
int cssInsertPos = options.CssStyles.LastIndexOf("</style>");
options.CssStyles = options.CssStyles.Insert(cssInsertPos,
".PlainText{" +
" font-family: sans-serif;" +
"}"
);
eml.Save("message.mhtml", options);

Preservando el cuerpo RTF al convertir MSG a EML

La conversión de un archivo MSG a EML preservando el cuerpo RTF se puede hacer de dos maneras:

Ambas propiedades obtienen o establecen un valor que indica si mantener el cuerpo rtf en MailMessage.

Los siguientes fragmentos de código muestran cómo convertir un archivo MSG a EML y preservar el cuerpo RTF:

var loadOptions = new MsgLoadOptions
{
    PreserveRtfContent = true
};

var eml = MailMessage.Load("my.msg", loadOptions);
var conversionOptions = new MailConversionOptions
{
    PreserveRtfContent = true
};

var msg = MapiMessage.Load("my.msg");

var eml = msg.ToMailMessage(conversionOptions);

Exportando Correo Electrónico a EML

El siguiente fragmento de código le muestra cómo exportar correos electrónicos a EML.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
string dataDir = RunExamples.GetDataDir_Email();
MailMessage msg = MailMessage.Load(dataDir + "Message.eml");
msg.Save(dataDir + "ExporttoEml_out.eml", SaveOptions.DefaultEml);

Guardando Mensaje como HTML

La clase HtmlSaveOptions le permite exportar el cuerpo del mensaje a HTML. El siguiente fragmento de código le muestra cómo guardar un mensaje como HTML.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
MailMessage message = MailMessage.Load(dataDir + "Message.eml");
message.Save(dataDir + "SaveAsHTML_out.html", SaveOptions.DefaultHtml);
// OR
MailMessage eml = MailMessage.Load(dataDir + "Message.eml");
HtmlSaveOptions options = SaveOptions.DefaultHtml;
options.EmbedResources = false;
options.HtmlFormatOptions = HtmlFormatOptions.WriteHeader | HtmlFormatOptions.WriteCompleteEmailAddress; //save the message headers to output HTML using the formatting options
eml.Save(dataDir + "SaveAsHTML1_out.html", options);

Guardando como HTML sin Embebidos Recursos

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
var fileName = "EmailWithAttandEmbedded.eml";
var filePath = Path.Combine(dataDir, fileName);
MailMessage msg = MailMessage.Load(filePath);
var outFileName = Path.Combine(dataDir, fileName + ".html");
var options = new HtmlSaveOptions()
{
EmbedResources = false,
SaveResourceHandler =
(AttachmentBase attachment, out string resourcePath) =>
{
attachment.Save(Path.Combine(dataDir, attachment.ContentId));
resourcePath = Path.Combine(".", attachment.ContentId);
}
};
msg.Save(outFileName, options);

Guardando Mensaje como un archivo de plantilla de Outlook (.oft)

El siguiente fragmento de código le muestra cómo guardar un mensaje como un archivo de plantilla de outlook (.oft).

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
using (MailMessage eml = new MailMessage("test@from.to", "test@to.to", "template subject", "Template body"))
{
string oftEmlFileName = "EmlAsOft_out.oft";
MsgSaveOptions options = SaveOptions.DefaultMsgUnicode;
options.SaveAsTemplate = true;
eml.Save(dataDir + oftEmlFileName, options);
}