Načíst a uložit e‑mailovou zprávu

Načíst e‑mailovou zprávu

Načíst z EML

Tato sekce popisuje, jak načíst soubor EML do objektu MailMessage pomocí EmlLoadOptions třída. Třída EmlLoadOptions poskytuje různé možnosti přizpůsobení načítání souboru EML, například zachování formátů vložených zpráv nebo řízení chování načítání TNEF příloh.

  1. Inicializujte instanci třídy EmlLoadOptions.
  2. Nastavte možnosti načítání podle potřeby.
  3. Použijte MailMessage.Load() metoda pro načtení souboru EML s určenými možnostmi.
using Aspose.Email;

// Initialize EmlLoadOptions
var loadOptions = new EmlLoadOptions
{
    // Configure load options
    PreferredTextEncoding = Encoding.UTF8, // Sets preferred encoding for the message
    PreserveEmbeddedMessageFormat = true, // Preserve format of embedded messages
    PreserveTnefAttachments = true, // Control TNEF attachment loading
    RemoveSignature = false // Do not remove the signature
};

// Load the EML file
var eml = MailMessage.Load("file.eml", loadOptions);

Vlastnosti EmlLoadOptions

  • PreferredTextEncoding: Nastavuje preferované kódování předmětu a těla zprávy. Výchozí hodnota je null.
  • PreserveEmbeddedMessageFormat: Udává, zda během načítání zachovat formát vložených zpráv. Výchozí hodnota je false.
  • PreserveTnefAttachments: Řídí chování načítání TNEF příloh. Výchozí hodnota je false.
  • RemoveSignature: Udává, zda má být během načítání odstraněn podpis. Výchozí hodnota je false.

Zachovat formát vložené zprávy

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

Načíst zprávu s podpisem/bez podpisu

Zachování podpisu je ve výchozím nastavení podporováno při načítání souborů EML. Pro odebrání podpisu můžete nastavit LoadOptions.RemoveSignature nastavte vlastnost na true.

Níže uvedený ukázkový kód ukazuje, jak při načítání zprávy odebrat podpis:

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

Načíst z EMLX

Následující část popisuje načítání souboru EMLX pomocí EmlxLoadOptions třída. Tato třída poskytuje možnosti podobné EmlLoadOptions, nabízející kontrolu nad kódováním, odstraňováním podpisu a další.

  1. Vytvořte instanci třídy EmlxLoadOptions.
  2. Nakonfigurujte vlastnosti dle potřeby.
  3. Použijte MailMessage.Load() metoda pro načtení souboru EMLX.
using Aspose.Email;

// Instantiate EmlxLoadOptions
var loadOptions = new EmlxLoadOptions
{
    // Configure load options
    PreferredTextEncoding = Encoding.UTF8, // Set encoding preference
    PreserveEmbeddedMessageFormat = true, // Preserve embedded message formats
    RemoveSignature = true // Remove signatures during loading
};

// Load the EMLX file
var emlx = MailMessage.Load("file.emlx", loadOptions);

Vlastnosti EmlxLoadOptions

Načíst z HTML

Naučte se, jak načíst HTML soubor do MailMessage pomocí HtmlLoadOptions třída. Tato třída je speciálně navržena pro zpracování HTML obsahu s možnostmi správy zdrojů a přidání zobrazení prostého textu.

  1. Inicializujte instanci třídy HtmlLoadOptions.
  2. Nakonfigurujte potřebné vlastnosti.
  3. Použijte MailMessage.Load() metoda pro načtení HTML souboru se zadanými možnostmi.
using Aspose.Email;

// Initialize HtmlLoadOptions
var loadOptions = new HtmlLoadOptions
{
    // Configure load options
    PathToResources = "resources/", // Path to directory containing resource files
    PreferredTextEncoding = Encoding.UTF8, // Set encoding preference
    ShouldAddPlainTextView = true // Add plain text view of the body
};

// Load the HTML file
var html = MailMessage.Load("file.html", loadOptions);

Vlastnosti HtmlLoadOptions

  • PathToResources: Definuje cestu k adresáři obsahujícím soubory zdrojů (např. obrázky).
  • PreferredTextEncoding: Nastavuje preferované kódování pro předmět a tělo zprávy. Výchozí hodnota je null.
  • PreserveEmbeddedMessageFormat: Určuje, zda zachovat formát vložených zpráv. Výchozí hodnota je false.
  • ShouldAddPlainTextView: Určuje, zda přidat zobrazení prostého textu těla zprávy. Výchozí hodnota je false.

Načíst z MHTML

Tato část vysvětluje, jak načíst soubor MHTML pomocí MhtmlLoadOptions třída. Třída MhtmlLoadOptions nabízí možnosti pro správu kódování, zachování formátů vložených zpráv a zpracování TNEF příloh.

  1. Vytvořte instanci třídy MhtmlLoadOptions.
  2. Nakonfigurujte požadované vlastnosti.
  3. Načtěte MHTML soubor pomocí MailMessage.Load() metoda.
using Aspose.Email;

// Create MhtmlLoadOptions
var loadOptions = new MhtmlLoadOptions
{
    // Set load options
    PreferredTextEncoding = Encoding.UTF8, // Set encoding preference
    PreserveEmbeddedMessageFormat = true, // Preserve format of embedded messages
    PreserveTnefAttachments = true, // Handle TNEF attachments
    RemoveSignature = false // Keep the signature
};

// Load the MHTML file
var mhtml = MailMessage.Load("file.mht", loadOptions);

Vlastnosti MhtmlLoadOptions

  • MessageFormat: Reprezentuje formát poštovní zprávy, který může být EML, MSG nebo MHTML. Výchozí hodnota je EML.
  • PreferredTextEncoding: Nastavuje preferované kódování předmětu a těla zprávy. Výchozí hodnota je null.
  • PreserveEmbeddedMessageFormat: Určuje, zda zachovat formát vložených zpráv. Výchozí hodnota je false.
  • PreserveTnefAttachments: Řídí chování načítání TNEF příloh. Výchozí hodnota je false.
  • RemoveSignature: Udává, zda během načítání odstranit podpis. Výchozí hodnota je false.

Načíst z MSG

Tato část vysvětluje, jak načíst soubor MSG do objektu MailMessage pomocí MsgLoadOptions třída. Třída MsgLoadOptions nabízí různé vlastnosti pro řízení načítání MSG souborů, včetně možností zachovat obsah RTF nebo spravovat TNEF přílohy.

  1. Vytvořte instanci třídy MsgLoadOptions.
  2. Nastavte požadované vlastnosti pro přizpůsobení načítání.
  3. Načtěte soubor MSG pomocí MailMessage.Load() metoda.
using Aspose.Email;

// Create MsgLoadOptions
var loadOptions = new MsgLoadOptions
{
    // Set load options
    KeepOriginalEmailAddresses = true, // Preserve original email addresses
    PreferredTextEncoding = Encoding.UTF8, // Set preferred encoding
    PreserveRtfContent = true, // Keep RTF content in the message
    PreserveTnefAttachments = true, // Handle TNEF attachments
    RemoveSignature = false, // Keep the signature
    Timeout = 5000 // Set timeout to 5 seconds
};

// Load the MSG file
var msg = MailMessage.Load("file.msg", loadOptions);

Vlastnosti MsgLoadOptions

  • KeepOriginalEmailAddresses: Udává, zda zachovat původní e‑mailové adresy. Výchozí hodnota je false.
  • PreferredTextEncoding: Definuje preferované kódování pro předmět a tělo zprávy. Výchozí hodnota je null.
  • PreserveEmbeddedMessageFormat: Určuje, zda má být zachován formát vložených zpráv. Výchozí hodnota je false.
  • PreserveRtfContent: Určuje, zda zachovat obsah těla RTF v MailMessage. Výchozí hodnota je false.
  • PreserveTnefAttachments: Řídí chování načítání TNEF příloh. Výchozí hodnota je false.
  • RemoveSignature: Určuje, zda odebrat podpis během načítání. Výchozí hodnota je false.
  • Časový limit: Omezuje čas formátování v milisekundách během konverze. Výchozí hodnota je 3000 ms.

Načíst z TNEF

Naučte se, jak načíst soubor TNEF eml pomocí TnefLoadOptions třída. Tato třída poskytuje možnosti pro správu kódování a odstraňování podpisů během načítání.

  1. Vytvořte instanci TnefLoadOptions.
  2. Nastavte vlastnosti podle potřeby.
  3. Použijte MailMessage.Load() metoda pro načtení souboru TNEF.
using Aspose.Email;

// Instantiate TnefLoadOptions
var loadOptions = new TnefLoadOptions
{
    // Configure load options
    PreferredTextEncoding = Encoding.UTF8, // Set encoding preference
    PreserveEmbeddedMessageFormat = true, // Preserve embedded message formats
    RemoveSignature = true // Remove signatures during loading
};

// Load the TNEF file
var tnef = MailMessage.Load("file.eml", loadOptions);

Vlastnosti TnefLoadOptions

  • MessageFormat: Reprezentuje formát e‑mailové zprávy, např. EML, MSG nebo MHTML. Výchozí formát je EML.
  • PreferredTextEncoding: Nastavuje preferované kódování předmětu a těla zprávy. Výchozí hodnota je null.
  • PreserveEmbeddedMessageFormat: Udává, zda zachovat formát vložených zpráv. Výchozí hodnota je false.
  • RemoveSignature: Udává, zda během načítání odstranit podpis. Výchozí hodnota je false.

Načíst zprávu z knihovny dokumentů Microsoft SharePoint

Můžete číst emailové zprávy uložené v knihovně dokumentů Microsoft SharePoint a načíst je do MailMessage objekt. Pro přístup k souborům v knihovně dokumentů SharePoint musí být na systému nainstalováno SDK SharePoint. SDK poskytuje API potřebné k přihlášení a přístupu k souborům z knihovny dokumentů.

Níže uvedený příklad předpokládá, že soubor zprávy Microsoft Outlook (.msg) je již uložen ve složce Sdílené dokumenty knihovny SharePoint. SDK SharePoint se používá k načtení souboru zprávy do proudu, který je následně předán MailMessage.Load metoda. Po načtení lze přistupovat k vlastnostem zprávy (předmět, textové tělo, HTML tělo atd.). Pro informace o instalaci a konfiguraci Microsoft SharePoint Server a SDK prosím viz příslušné sekce v knihovně MSDN.

// Private members
private SPSite site = null;
private SPWeb web = null;

private void EstablishSharepoint()
{
    site = new SPSite("http://localhost/Site1");
    web = site.OpenWeb();
}

private void button2_Click(object sender, EventArgs e)
{
    SPSecurity.CodeToRunElevated elevatedGetSite = new SPSecurity.CodeToRunElevated(EstablishSharepoint);
    SPSecurity.RunWithElevatedPrivileges(elevatedGetSite);

    // Path to the MSG file stored in the Shared Documents folder
    SPFile msgFile = web.GetFile("Shared Documents/Test.msg");

    // Read the file into a memory stream
    MemoryStream fileStream = new MemoryStream();
    byte[] currentFileContent = msgFile.OpenBinary();
    fileStream.Write(currentFileContent, 0, currentFileContent.Length);
    fileStream.Position = 0;

    // Create an instance of the MailMessage class and pass the memory stream of the MSG file to it
    MailMessage msg = MailMessage.Load(fileStream, new MsgLoadOptions());
    fileStream.Close();
    fileStream.Dispose();

    // Access the MailMessage class' public properties
    Console.WriteLine("Subject: " + msg.Subject);
    Console.WriteLine("From: " + msg.From.ToString());
    Console.WriteLine("Text Body: " + msg.TextBody);
}

Detekce formátů souborů

Aspose.Email API poskytuje možnost detekovat formát souboru poskytnuté zprávy. The DetectFileFormat metoda FileFormatUtil třída může být použita k dosažení tohoto cíle. Následující typy a metody lze použít k detekci formátu načteného souboru.

Následující úryvek kódu vám ukáže, jak detekovat formáty souborů.

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

Uložit a převést zprávy

Aspose.Email usnadňuje konverzi libovolného typu zprávy do jiného formátu. K demonstraci této funkce kód v tomto článku načte tři typy zpráv z disku a uloží je zpět v jiných formátech. Základní třída SaveOptions a třídy EmlSaveOptions, MsgSaveOptions, MhtSaveOptions, HtmlSaveOptions pro další nastavení při ukládání MailMessage Lze použít pro ukládání zpráv do jiných formátů. Článek ukazuje, jak použít tyto třídy k uložení ukázkového e‑mailu jako:

  • EML formát.
  • Outlook MSG.
  • MHTML formát.
  • HTML formát.

Uložit jako EML

Následující úryvek kódu ukazuje, jak načíst EML zprávu a uložit ji na disk ve stejném formátu.

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

Hranice původní zprávy

Když je EML zpráva načtena a znovu uložena jako EML, hranice původní zprávy jsou ve výchozím nastavení zachovány, takže žádná konfigurace není nutná. Starší verze knihovny nabízely EmlSaveOptions.PreserveOriginalBoundaries vlastnost pro tento účel. Tato vlastnost byla odstraněna a zachování původních hranic je nyní výchozím chováním.

Přizpůsobení MIME hranic

Pokud potřebujete, aby hranice sledovaly konkrétní vzor, použijte BoundariesTemplate vlastnost třídy EmlSaveOptions třída. Definuje šablonu používanou k vytvoření MIME hranic pro uloženou zprávu. Výchozí hodnota je null, což znamená, že hranice jsou generovány knihovnou. V šabloně jsou podporovány dva zástupné znaky:

  • {#} – číslo hranice.
  • {guid} – vygenerovaný GUID.

Následující úryvek kódu ukazuje, jak načíst EML a uložit jej jako EML s vlastními MIME hranicemi.

// The path to the File directory.
string dataDir = RunExamples.GetDataDir_Email();

MailMessage mailMessage = MailMessage.Load(dataDir + "Attachments.eml");

// Save as eml with a custom boundary template
EmlSaveOptions emlSaveOptions = new EmlSaveOptions(MailMessageSaveType.EmlFormat)
{
    BoundariesTemplate = "boundary_{#}_{guid}"
};
mailMessage.Save(dataDir + "CustomBoundaries_out.eml", emlSaveOptions);

Zachovat TNEF přílohy

Následující úryvek kódu vám ukáže, jak uložit jako EML zachovávajíc přílohy TNEF.

// The path to the File directory.
string dataDir = RunExamples.GetDataDir_Email();

MailMessage mailMessage = MailMessage.Load(dataDir + "tnefEML.eml");

// Save as eml with preserved attachment
EmlSaveOptions emlSaveOptions = new EmlSaveOptions(MailMessageSaveType.EmlFormat)
{
    FileCompatibilityMode = FileCompatibilityMode.PreserveTnefAttachments
};
mailMessage.Save(dataDir + "PreserveTNEFAttachment_out.eml", emlSaveOptions);

Uložit EML do MSG

Následující úryvek kódu ukazuje, jak načíst EML zprávu a převést ji na MSG pomocí vhodné volby z SaveOptions.

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

Zachovat data

The MsgSaveOptions třída vám umožňuje uložit zdrojovou zprávu jako soubor Outlook Message (MSG) se zachováním dat. Následující úryvek kódu ukazuje, jak uložit jako MSG s zachovanými daty.

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

Uložit EML jako MHTML

Různé možnosti MHTML lze použít k dosažení požadovaných výsledků. Následující úryvek kódu vám ukáže, jak načíst zprávu EML do MailMessage a převést ji na MHTML s datem zprávy v UTC systému.


// Set options for MHTML output
MhtSaveOptions saveOptions = SaveOptions.DefaultMhtml;
saveOptions.PreserveOriginalDate = false; // save a message date as UTC date

// Initialize and load an existing EML file
using (MailMessage mailMessage = MailMessage.Load(folderPath + "Message.eml"))
{
    mailMessage.Save(folderPath + "Message_out.mhtml", saveOptions);
}

Možnosti konverze

The MhtSaveOptions Třída poskytuje další možnosti pro ukládání e‑mailových zpráv do formátu MHTML. Enumerator MhtFormatOptions Umožňuje zapisovat další informace o e‑mailu do výstupního MHTML. Následující další pole lze zapsat:

  • WriteHeader – zapíše hlavičku e‑mailu do výstupního souboru.
  • WriteOutlineAttachments – zapíše strukturu příloh do výstupního souboru.
  • WriteCompleteEmailAddress – zapíše úplnou e‑mailovou adresu do výstupního souboru.
  • NoEncodeCharacters – nemělo by být použito žádné přenosové kódování znaků.
  • HideExtraPrintHeader – skryje další tiskovou hlavičku v horní části výstupního souboru.
  • WriteCompleteToEmailAddress – zapíše úplnou adresu příjemce do výstupního souboru.
  • WriteCompleteFromEmailAddress – zapíše úplnou adresu odesílatele do výstupního souboru.
  • WriteCompleteCcEmailAddress – zapíše úplné e‑mailové adresy všech příjemců s CC do výstupního souboru.
  • WriteCompleteBccEmailAddress – zapíše úplnou e‑mailovou adresu všech příjemců s BCC do výstupního souboru.
  • RenderCalendarEvent – zapíše text z kalendářové události do výstupního souboru.
  • SkipByteOrderMarkInBody – přeskočit bajty Byte Order Mark (BOM) v těle výstupního souboru.
  • RenderVCardInfo – zapíše text z VCard AlternativeView do výstupního souboru.
  • DisplayAsOutlook – zobrazí hlavičku From.
  • RenderTaskFields – zapíše specifická pole úkolu do výstupního souboru.
  • None – Žádné nastavení neuvedeno.

Následující úryvek kódu vám ukáže, jak převést soubory EML do MHTML s volitelnými nastaveními.

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 information to the output 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);

Vykreslit kalendářové události

The MhtFormatOptions.RenderCalendarEvent vykresluje události kalendáře do výstupního MHTML. Následující úryvek kódu ukazuje, jak renderovat události kalendáře při převodu do MHTML.

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

Export e‑mailu do MHT bez vložených obrázků

The SkipInlineImages vlastnost třídy MhtSaveOptions třída určuje, zda při ukládání do MHTML přeskočit reference na obrázky. Výchozí hodnota je false.

MailMessage eml = MailMessage.Load(Path.Combine(dataDir, "Message.eml"));

MhtSaveOptions mhtSaveOptions = new MhtSaveOptions
{
    SkipInlineImages = true
};

eml.Save(Path.Combine(dataDir, "EmlToMhtmlWithoutInlineImages_out.mht"), mhtSaveOptions);

Export e‑mailu do MHT s upraveným časovým pásmem

MailMessage třída poskytuje TimeZoneOffset vlastnost pro nastavení vlastního časového pásma při exportu do MHT. Následující úryvek kódu vám ukazuje, jak exportovat e‑mail do MHT s přizpůsobeným časovým pásmem.

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

Úprava fontu

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

Uložit EML jako HTML

The HtmlSaveOptions třída umožňuje exportovat tělo zprávy do HTML. Následující úryvek kódu vám ukazuje, jak uložit zprávu jako HTML.

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.HtmlFormatOptions = HtmlFormatOptions.WriteHeader | HtmlFormatOptions.WriteCompleteEmailAddress; //save the message headers to output HTML using the formatting options
eml.Save(dataDir + "SaveAsHTML1_out.html", options);

Ovládání způsobu vykreslování zdrojů

The ResourceRenderingMode vlastnost třídy HtmlSaveOptions třída definuje, jak jsou zdroje zprávy (např. vložené obrázky) zapisovány do výstupního HTML. Přijímá hodnoty ResourceRenderingMode enumerace:

  • EmbedIntoHtml – vložit zdroje do HTML jako řetězce base64. Toto je výchozí hodnota.
  • SaveToFile – uložit zdroje do souborů a vložit cestu ke každému souboru do src tagu.
  • SubstituteFromFile – použít vlastní soubor jako ikonu a vložit jeho cestu do src tagu.
  • None – nevyrenderovat zdroje v HTML.

Když nejsou zdroje vloženy, SaveResourceHandler delegát je volán pro každou přílohu zprávy, což vám umožní rozhodnout, kde bude každá zdrojová položka uložena a jaká cesta bude zapsána do HTML.

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()
{
    ResourceRenderingMode = ResourceRenderingMode.SaveToFile,
    SaveResourceHandler =
        (AttachmentBase attachment, out string resourcePath) =>
        {
            attachment.Save(Path.Combine(dataDir, attachment.ContentId));
            resourcePath = Path.Combine(".", attachment.ContentId);
        }
};

msg.Save(outFileName, options);

Uložit EML jako OFT

Následující úryvek kódu vám ukazuje, jak uložit zprávu jako šablonu Outlooku (.oft) soubor.

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

Převést EML na MSG (MailMessage na MapiMessage)

Pro převod MailMessage objekt načtený ze souboru EML do MapiMessage objekt, použijte MapiConversionOptions třída. Tato konverze je často nutná, protože tyto dva objekty slouží různým účelům a uspokojují odlišné potřeby při zpracování e‑mailů. MapiMessage je speciálně navrženo pro kompatibilitu s Microsoft Outlook a Exchange Server, protože se řídí formátem Messaging Application Programming Interface (MAPI). To zajišťuje, že e‑mailové zprávy převedené do souborů MSG jsou plně kompatibilní s produkty Microsoftu, což umožňuje je otevírat, upravovat a spravovat přímo v Outlooku.

Tato konverze je také nutná, když je třeba e‑mailové zprávy archivovat, indexovat nebo zpracovávat úložišti, která vyžadují formát MAPI, například úložiště PST/OST, OLM. Tento MapiConversionOptions Třída vám umožňuje zadat další možnosti, jako je zachování původního formátu zprávy, zachování původních dat a komprese těla RTF během konverze. Následující ukázkový kód ukazuje, jak načíst e‑mail ze souboru ve formátu .eml a převést jej do formátu Outlook .msg s možností přizpůsobení, ale s zajištěním, že určité charakteristiky původního e‑mailu jsou během konverze zachovány.

  1. Vytvořte instanci MapiConversionOptions a nakonfigurujte jeho vlastnosti.
  2. Převést MailMessage objekt na MapiMessage objekt používající nakonfigurované možnosti konverze.
MailMessage eml = MailMessage.Load("email.eml", new EmlLoadOptions());

// Create an instance of MapiConversionOptions
var conversionOptions = new MapiConversionOptions
{
    // Configure MapiConversionOptions
    Format = OutlookMessageFormat.Unicode, // Use Unicode format for MSG
    PreserveEmbeddedMessageFormat = true, // Preserve the format of embedded messages
    PreserveOriginalAddresses = true, // Keep original email addresses
    PreserveOriginalDates = true, // Preserve original dates
    PreserveEmptyDates = false, // Generate new dates if original are empty
    RemoveSignature = false, // Do not remove the signature
    UseBodyCompression = true, // Enable RTF body compression
    ForcedRtfBodyForAppointment = false // Disable forced RTF body for appointments
};

// Convert MailMessage to MapiMessage
MapiMessage msg = MapiMessage.FromMailMessage(eml, conversionOptions);

Dostupné vlastnosti MapiConversionOptions

  • ASCIIFormat: Vrací MapiConversionOptions konfigurováno s OutlookMessageFormat jako ASCII, s PreserveSignature nastavte na false a UseBodyCompression nastavte na false. Tato možnost je užitečná, když potřebujete konverzi do prostého ASCII formátu.

  • UnicodeFormat: Vrací MapiConversionOptions s OutlookMessageFormat nastavte na Unicode a oba PreserveSignature a UseBodyCompression nastavte na false. Použijte tuto možnost pro komplexnější podporu znaků v MSG souborech.

  • ForcedRtfBodyForAppointment: Když je nastaveno na true, vynutí použití RTF těla pro kalendářové schůzky. To je užitečné, pokud chcete zajistit kompatibilitu s některými e‑mailovými klienty. Výchozí hodnota je true.

  • Format: Určuje výstupní formát pro MSG soubor. Může být nastaven na jeden z OutlookMessageFormat.ASCII nebo OutlookMessageFormat.Unicode, což řídí, zda převodní MSG použije kódování ASCII nebo Unicode.

  • PreserveEmbeddedMessageFormat: Určuje, zda během konverze na zachovat původní formát EML vložených zpráv MapiMessage. Nastavením na true zajistíte, že vložené e‑mailové zprávy si zachovají původní strukturu. Výchozí hodnota je false.

  • PreserveEmptyDates: Když je nastaveno na true, zachová původní data uložení a změny z EML. Jinak budou vygenerována nová data, pokud jsou původní prázdná.

  • PreserveOriginalAddresses: Pokud je nastaveno na true, zachovává původní e‑mailové adresy bez ověřování. To je užitečné při práci s adresami, které nemusí splňovat přísné standardy, ale je třeba je zachovat tak, jak jsou. Výchozí hodnota je false.

  • PreserveOriginalDates: Zajišťuje, že původní data odeslání a přijetí jsou během konverze zachována. Nastavením na true se tato data uchovají pro lepší historickou přesnost.

  • RemoveSignature: Ovládá, zda bude během konverze digitální podpis, pokud existuje, odebrán ze zprávy. Výchozí hodnota je false, což znamená, že podpis bude zachován, pokud není výslovně odstraněn.

  • UseBodyCompression: Povolení komprese těla RTF, pokud je nastaveno na true. To může pomoci snížit velikost MSG souboru, zejména u velkých zpráv s bohatým formátováním.