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.
- Classe FileFormatType
- Classe FileFormatInfo
- Classe FileFormatUtil
- Método FileFormatUtil.DetectFileFormat(Stream)
- Método FileFormatUtil.DetectFileFormat(String)
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:
- 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);
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:
-
usando a propriedade MsgLoadOptions.PreserveRtfContent da classe MsgLoadOptions;
-
usando a propriedade MailConversionOptions.PreserveRtfContent da classe MailConversionOptions;
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); | |
} |