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.
- Clase FileFormatType
- Clase FileFormatInfo
- Clase FileFormatUtil
- Método FileFormatUtil.DetectFileFormat(Stream)
- Método FileFormatUtil.DetectFileFormat(String)
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:
- Método SecureEmailManager.CheckSignature(MailMessage msg).
- Método SecureEmailManager.CheckSignature(MailMessage msg, X509Certificate2 certificateForDecrypt).
- Método SecureEmailManager.CheckSignature(MailMessage msg, X509Certificate2 certificateForDecrypt, X509Store store).
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:
-
utilizando la propiedad MsgLoadOptions.PreserveRtfContent de la clase MsgLoadOptions;
-
utilizando la propiedad MailConversionOptions.PreserveRtfContent de la clase MailConversionOptions;
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); | |
} |