Carregando e Salvando Mensagem

Carregando e Salvando Mensagens

Detectando Formatos de Arquivo

A API Aspose.Email fornece a capacidade de detectar o formato do arquivo da mensagem fornecida. O método DetectFileFormat da classe FileFormatUtil pode ser usado para alcançar isso. As seguintes classes e métodos podem ser usados para detectar o formato do arquivo carregado.

O seguinte trecho de código mostra como detectar formatos de arquivo.

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

Carregando uma Mensagem com Opções de Carregamento

O seguinte trecho de código mostra como carregar uma mensagem com opções de carregamento.

// 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 o Formato de Mensagem Embutido durante o Carregamento

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

Carregando uma Mensagem Preservando ou Removendo uma Assinatura

A preservação da assinatura é suportada por padrão ao carregar arquivos EML. Para remover a assinatura, você pode definir a propriedade LoadOptions.RemoveSignature como true.

O exemplo de código abaixo mostra como remover uma assinatura ao carregar uma mensagem:

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

Verificando a Assinatura de E-mails Seguros

A classe SecureEmailManager permite que você verifique a assinatura de objetos MailMessage seguros.

A classe SmimeResult armazena os resultados da verificação.

Os seguintes métodos da classe SecureEmailManager e um trecho de código permitirão que você processe uma assinatura:

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

Salvando e Convertendo Mensagens

Aspose.Email torna fácil converter qualquer tipo de mensagem para outro formato. Para demonstrar esse recurso, o código deste artigo carrega três tipos de mensagens do disco e as salva de volta em outros formatos. A classe base SaveOptions e as classes EmlSaveOptions, MsgSaveOptions, MhtSaveOptions, HtmlSaveOptions para configurações adicionais ao salvar MailMessage podem ser usadas para salvar mensagens em outros formatos. O artigo mostra como usar essas classes para salvar um e-mail de exemplo como:

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

Carregar e Salvar uma Mensagem EML

O seguinte trecho de código mostra como carregar uma mensagem EML e salvá-la no disco no mesmo 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);

Carregar e Salvar uma Mensagem EML Preservando as Fronteiras Originais

O seguinte trecho de código mostra como carregar EML e salvar como EML preservando as fronteiras originais.

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

Salvando como EML Preservando Anexos TNEF

O seguinte trecho de código mostra como salvar como EML preservando anexos 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);

Salvar EML como MSG

O seguinte trecho de código mostra como carregar uma mensagem EML e convertê-la em MSG usando a opção apropriada da 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);

Salvando como MSG com Datas Preservadas

A classe MsgSaveOptions permite que você salve a mensagem original como um arquivo de Mensagem do Outlook (MSG) preservando datas. O seguinte trecho de código mostra como salvar como MSG com Datas 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);

Salvando MailMessage como MHTML

Diferentes opções de MHTML podem ser usadas para obter os resultados desejados. O seguinte trecho de código mostra como carregar uma mensagem EML em MailMessage e convertê-la em MHTML com uma data da mensagem no sistema UTC.

// Para exemplos completos e arquivos de dados, por favor acesse https://github.com/aspose-email/Aspose.Email-for-.NET

// Definir opções para saída MHTML
MhtSaveOptions saveOptions = SaveOptions.DefaultMhtml;
saveOptions.PreserveOriginalDate = false; // salvar uma data da mensagem como data UTC

// Inicializar e carregar um arquivo EML existente
using (MailMessage mailMessage = MailMessage.Load(folderPath + "Message.eml"))
{
    mailMessage.Save(folderPath + "Message_out.mhtml", saveOptions);
}

Convertendo para MHTML com Configurações Opcionais

A classe MhtSaveOptions fornece opções adicionais para salvar mensagens de e-mail no formato MHTML. O enumerador MhtFormatOptions possibilita escrever informações adicionais do e-mail no MHTML de saída. Os seguintes campos adicionais podem ser escritos:

  • WriteHeader – escrever o cabeçalho do e-mail no arquivo de saída.
  • WriteOutlineAttachments – escrever anexos de contorno no arquivo de saída.
  • WriteCompleteEmailAddress – escrever o endereço de e-mail completo no arquivo de saída.
  • NoEncodeCharacters – nenhuma codificação de transferência de caracteres deve ser usada.
  • HideExtraPrintHeader – ocultar cabeçalho extra de impressão do topo do arquivo de saída.
  • WriteCompleteToEmailAddress – escrever o endereço de e-mail completo do destinatário no arquivo de saída.
  • WriteCompleteFromEmailAddress – escrever o endereço de e-mail completo do remetente no arquivo de saída.
  • WriteCompleteCcEmailAddress – escrever os endereços de e-mail completos de qualquer destinatário com cópia carbono no arquivo de saída.
  • WriteCompleteBccEmailAddress – escrever o endereço de e-mail completo de qualquer destinatário com cópia carbono oculta no arquivo de saída.
  • RenderCalendarEvent – escrever texto do evento do calendário no arquivo de saída.
  • SkipByteOrderMarkInBody – escrever bytes de Byte Order Mark(BOM) no arquivo de saída.
  • RenderVCardInfo – escrever texto da VCard AlternativeView no arquivo de saída.
  • DisplayAsOutlook – exibir o cabeçalho From.
  • RenderTaskFields – escreve campos de Tarefa específicos no arquivo de saída.
  • None – Nenhuma configuração especificada.

O seguinte trecho de código mostra como converter arquivos EML para MHTML com configurações opcionais.

// 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 Calendário ao Converter para MHTML

As MhtFormatOptions.RenderCalendarEvent renderiza os eventos do Calendário para o MTHML de saída. O seguinte trecho de código mostra como renderizar eventos de calendário ao converter para 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 E-mail para MHT sem Imagens Inline

// 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 E-mail para MHT com Fuso Horário personalizado

A classe MailMessage fornece a propriedade TimeZoneOffset para definir um Fuso Horário personalizado ao exportar para MHT. O seguinte trecho de código mostra como exportar e-mail para MHT com Fuso Horário personalizado.

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

Mudando a Fonte ao Converter para 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 o corpo RTF ao converter MSG para EML

A conversão de um arquivo MSG para EML preservando o corpo RTF pode ser feita de duas maneiras:

Ambas as propriedades obtêm ou definem um valor indicando se devem manter o corpo rtf em MailMessage.

Os seguintes trechos de código mostram como converter um arquivo MSG para EML e preservar o corpo 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 E-mail para EML

O seguinte trecho de código mostra como exportar e-mails para 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);

Salvando Mensagem como arquivo HTML

A classe HtmlSaveOptions permite que você exporte o corpo da mensagem para HTML. O seguinte trecho de código mostra como salvar uma mensagem 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);

Salvando como HTML sem Embutir 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);

Salvando Mensagem como arquivo de Modelo do Outlook (.oft)

O seguinte trecho de código mostra como salvar uma mensagem como um arquivo de modelo do 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);
}