E‑Mail‑Nachricht laden und speichern

E‑Mail‑Nachricht laden

Aus EML laden

Dieser Abschnitt beschreibt, wie eine EML‑Datei in ein MailMessage‑Objekt geladen wird mit dem EmlLoadOptions Klasse. Die EmlLoadOptions‑Klasse bietet verschiedene Optionen, um das Laden der EML‑Datei anzupassen, zum Beispiel das Beibehalten eingebetteter Nachrichtenformate oder die Steuerung des Ladens von TNEF‑Anhängen.

  1. Initialisieren Sie eine Instanz von EmlLoadOptions.
  2. Konfigurieren Sie die Ladeoptionen nach Bedarf.
  3. Verwenden Sie die MailMessage.Load() Methode zum Laden der EML‑Datei mit den angegebenen Optionen.
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);

Eigenschaften von EmlLoadOptions

Einbettungsnachrichtenformat beibehalten

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

Nachricht mit Signatur/l ohne Signatur laden

Die Signatur-Erhaltung ist standardmäßig beim Laden von EML-Dateien unterstützt. Um die Signatur zu entfernen, können Sie das LoadOptions.RemoveSignature Eigenschaft auf true setzen.

Das untenstehende Codebeispiel zeigt, wie man beim Laden einer Nachricht eine Signatur entfernt:

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

Aus EMLX laden

Der folgende Abschnitt behandelt das Laden einer EMLX-Datei mit dem EmlxLoadOptions Klasse. Diese Klasse bietet Optionen ähnlich wie EmlLoadOptions und ermöglicht die Steuerung von Kodierung, Signaturentfernung und mehr.

  1. Instanziieren Sie die EmlxLoadOptions.
  2. Konfigurieren Sie die Eigenschaften nach Bedarf.
  3. Verwenden Sie die MailMessage.Load() Methode zum Laden der EMLX-Datei.
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);

Eigenschaften von EmlxLoadOptions

  • PreferredTextEncoding: Legt die bevorzugte Kodierung für Betreff und Body der Nachricht fest. Standard ist null.
  • PreserveEmbeddedMessageFormat: Gibt an, ob das Format eingebetteter Nachrichten beibehalten werden soll. Standard ist false.
  • RemoveSignature: Gibt an, ob die Signatur beim Laden entfernt werden soll. Standard ist false.

Aus HTML laden

Erfahren Sie, wie Sie eine HTML-Datei in eine MailMessage laden mit dem HtmlLoadOptions Klasse. Diese Klasse ist speziell dafür konzipiert, HTML-Inhalte zu verarbeiten, mit Optionen zur Ressourcenverwaltung und zum Hinzufügen von Nur-Text-Ansichten.

  1. Initialisieren Sie eine Instanz von HtmlLoadOptions.
  2. Konfigurieren Sie die erforderlichen Eigenschaften.
  3. Verwenden Sie die MailMessage.Load() Methode, um die HTML-Datei mit den angegebenen Optionen zu laden.
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);

Eigenschaften von HtmlLoadOptions

  • PathToResources: Definiert den Pfad zu dem Verzeichnis, das Ressourcendateien (z. B. Bilder) enthält.
  • PreferredTextEncoding: Legt die bevorzugte Kodierung für Betreff und Body der Nachricht fest. Standard ist null.
  • PreserveEmbeddedMessageFormat: Bestimmt, ob das Format eingebetteter Nachrichten erhalten bleiben soll. Standard ist false.
  • ShouldAddPlainTextView: Gibt an, ob eine Nur-Text-Ansicht des Nachrichtenkörpers hinzugefügt werden soll. Standard ist false.

Aus MHTML laden

Dieser Abschnitt erklärt, wie man eine MHTML-Datei mittels MhtmlLoadOptions Klasse. Die MhtmlLoadOptions-Klasse bietet Optionen zur Verwaltung der Kodierung, zum Erhalt eingebetteter Nachrichtenformate und zur Handhabung von TNEF-Anhängen.

  1. Erstellen Sie eine Instanz von MhtmlLoadOptions.
  2. Konfigurieren Sie die gewünschten Eigenschaften.
  3. Laden Sie die MHTML-Datei mit der MailMessage.Load() Methode.
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);

Eigenschaften von MhtmlLoadOptions

  • MessageFormat: Stellt das Nachrichtenformat dar, das EML, MSG oder MHTML sein kann. Standard ist EML.
  • PreferredTextEncoding: Legt die bevorzugte Kodierung für Betreff und Body der Nachricht fest. Standard ist null.
  • PreserveEmbeddedMessageFormat: Bestimmt, ob das Format eingebetteter Nachrichten erhalten bleiben soll. Standard ist false.
  • PreserveTnefAttachments: Steuert das Laden von TNEF‑Anhängen. Standard ist false.
  • RemoveSignature: Gibt an, ob die Signatur beim Laden entfernt werden soll. Standard ist false.

Aus MSG laden

Dieser Abschnitt erklärt, wie man eine MSG-Datei in ein MailMessage-Objekt lädt mit dem MsgLoadOptions Klasse. Die MsgLoadOptions-Klasse bietet verschiedene Eigenschaften zur Handhabung des Ladens von MSG-Dateien, einschließlich Optionen zum Erhalt von RTF-Inhalten oder zur Verwaltung von TNEF-Anhängen.

  1. Erstellen Sie eine Instanz von MsgLoadOptions.
  2. Legen Sie die gewünschten Eigenschaften fest, um das Laden anzupassen.
  3. Laden Sie die MSG-Datei mit dem MailMessage.Load() Methode.
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);

Eigenschaften von MsgLoadOptions

  • KeepOriginalEmailAddresses: Gibt an, ob ursprüngliche E-Mail-Adressen beibehalten werden sollen. Standard ist false.
  • PreferredTextEncoding: Definiert die bevorzugte Kodierung für Betreff und Body der Nachricht. Standard ist null.
  • PreserveEmbeddedMessageFormat: Bestimmt, ob das Format eingebetteter Nachrichten erhalten bleiben soll. Standard ist false.
  • PreserveRtfContent: Gibt an, ob RTF-Body-Inhalt im MailMessage. Standard ist false.
  • PreserveTnefAttachments: Steuert das Laden von TNEF-Anhängen. Standard ist false.
  • RemoveSignature: Entscheidet, ob die Signatur beim Laden entfernt werden soll. Standard ist false.
  • Timeout: Begrenzt die Formatierungszeit in Millisekunden während der Konvertierung. Standard ist 3000 ms.

Aus TNEF laden

Erfahren Sie, wie Sie eine TNEF eml-Datei laden mit dem TnefLoadOptions Klasse. Diese Klasse bietet Optionen zur Verwaltung der Kodierung und zum Entfernen von Signaturen während des Ladevorgangs.

  1. Instanziieren Sie die TnefLoadOptions.
  2. Konfigurieren Sie die Eigenschaften nach Bedarf.
  3. Verwenden Sie die MailMessage.Load() Methode zum Laden der TNEF‑Datei.
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);

Eigenschaften von TnefLoadOptions

  • MessageFormat: Gibt das Format der Mail‑Nachricht an, z. B. EML, MSG oder MHTML. Standard ist EML.
  • PreferredTextEncoding: Legt die bevorzugte Kodierung für Betreff und Body der Nachricht fest. Standard ist null.
  • PreserveEmbeddedMessageFormat: Gibt an, ob das Format eingebetteter Nachrichten beibehalten werden soll. Standard ist false.
  • RemoveSignature: Gibt an, ob die Signatur beim Laden entfernt werden soll. Standard ist false.

Laden einer Nachricht aus einer Microsoft SharePoint‑Dokumentbibliothek

Sie können E‑Mail‑Nachrichten, die in einer Microsoft SharePoint‑Dokumentbibliothek gespeichert sind, lesen und in ein MailMessage Objekt. Um Dateien in einer SharePoint‑Dokumentbibliothek zuzugreifen, muss das SharePoint‑SDK auf dem System installiert sein. Das SDK liefert die API, die zum Anmelden und Zugriff auf Dateien aus der Dokumentbibliothek nötig ist.

Das untenstehende Beispiel geht davon aus, dass eine Microsoft Outlook‑Nachrichtendatei (.msg) ist bereits im Ordner „Gemeinsame Dokumente“ der SharePoint‑Dokumentbibliothek gespeichert. Das SharePoint‑SDK wird verwendet, um die Nachrichtendatei in einen Stream zu lesen, der dann an den MailMessage.Load Methode. Sobald geladen, können auf die Nachrichteneigenschaften (Betreff, Textkörper, HTML‑Körper usw.) zugegriffen werden. Für Informationen zur Installation und Konfiguration von Microsoft SharePoint Server und dem SDK verweisen wir auf die entsprechenden Abschnitte in der MSDN‑Bibliothek.

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

Erkennen von Dateiformaten

Aspose.Email‑API bietet die Möglichkeit, das Dateiformat der bereitgestellten Nachrichtendatei zu erkennen. Die DetectFileFormat Methode von FileFormatUtil Klasse kann verwendet werden, um dies zu erreichen. Die folgenden Typen und Methoden können zur Erkennung des geladenen Dateiformats verwendet werden.

Das folgende Code‑Snippet zeigt, wie Dateiformate erkannt werden können.

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

Nachrichten speichern und konvertieren

Aspose.Email erleichtert die Konvertierung beliebiger Nachrichtentypen in ein anderes Format. Um diese Funktion zu demonstrieren, lädt der Code in diesem Artikel drei Nachrichtentypen von der Festplatte und speichert sie in anderen Formaten zurück. Die Basisklasse SaveOptions und die Klassen EmlSaveOptions, MsgSaveOptions, MhtSaveOptions, HtmlSaveOptions für zusätzliche Einstellungen beim Speichern MailMessage kann zum Speichern von Nachrichten in andere Formate verwendet werden. Der Artikel zeigt, wie diese Klassen verwendet werden, um eine Beispiel‑E‑Mail zu speichern als:

  • EML‑Format.
  • Outlook‑MSG.
  • MHTML‑Format.
  • HTML‑Format.

Als EML speichern

Das folgende Code‑Snippet zeigt, wie Sie eine EML‑Nachricht laden und auf dem Datenträger im selben Format speichern.

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

Grenzen der Originalnachricht

Wenn eine EML‑Nachricht geladen und wieder als EML gespeichert wird, werden die Grenzen der Ursprungsnachricht standardmäßig beibehalten, sodass keine Konfiguration nötig ist, um sie zu erhalten. Frühere Versionen der Bibliothek boten ein EmlSaveOptions.PreserveOriginalBoundaries Eigenschaft zu diesem Zweck. Diese Eigenschaft wurde entfernt und das Beibehalten der Original‑Grenzen ist nun das Standardverhalten.

MIME‑Grenzen anpassen

Wenn Sie möchten, dass die Grenzen einem bestimmten Muster folgen, verwenden Sie die BoundariesTemplate Eigenschaft des EmlSaveOptions Klasse. Sie definiert die Vorlage, die zum Erzeugen von MIME‑Grenzen für die gespeicherte Nachricht verwendet wird. Der Standardwert ist null, was bedeutet, dass die Grenzen von der Bibliothek erzeugt werden. Zwei Platzhalter werden in der Vorlage unterstützt:

  • {#} – die Grenz‑Nummer.
  • {guid} – ein generierter GUID.

Das folgende Code‑Snippet zeigt, wie man EML lädt und es als EML mit benutzerdefinierten MIME‑Grenzen speichert.

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

TNEF-Anhänge erhalten

Das folgende Code‑Snippet zeigt, wie man als EML speichert und dabei TNEF‑Anhänge beibehält.

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

EML nach MSG speichern

Das folgende Code‑Snippet zeigt, wie Sie eine EML‑Nachricht laden und mithilfe der passenden Option aus 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);                      

Daten erhalten

Die MsgSaveOptions Klasse ermöglicht es Ihnen, die Quellnachricht als Outlook Message-Datei (MSG) zu speichern und dabei Daten beizubehalten. Das folgende Codebeispiel zeigt, wie man als MSG mit beibehaltenen Daten speichert.

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

EML nach MHTML speichern

Verschiedene MHTML‑Optionen können verwendet werden, um die gewünschten Ergebnisse zu erzielen. Das folgende Code‑Snippet zeigt, wie man eine EML‑Nachricht lädt in MailMessage und in MHTML mit einem Nachrichten‑Datum im UTC‑System konvertieren.


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

Konvertierungsoptionen

Die MhtSaveOptions Klasse stellt zusätzliche Optionen zum Speichern von E‑Mail‑Nachrichten im MHTML‑Format bereit. Der Aufzählungstyp MhtFormatOptions macht es möglich, zusätzliche E‑Mail‑Informationen in das AusgabemHTML zu schreiben. Die folgenden zusätzlichen Felder können geschrieben werden:

  • WriteHeader – schreibt die E‑Mail‑Kopfzeile in die Ausgabedatei.
  • WriteOutlineAttachments – schreibt Outline‑Anhänge in die Ausgabedatei.
  • WriteCompleteEmailAddress – schreibt die vollständige E‑Mail‑Adresse in die Ausgabedatei.
  • NoEncodeCharacters – es sollte keine Transferkodierung von Zeichen verwendet werden.
  • HideExtraPrintHeader – blendet zusätzliche Druckkopfzeile am oberen Rand der Ausgabedatei aus.
  • WriteCompleteToEmailAddress – schreibt die vollständige Empfänger‑E‑Mail‑Adresse in die Ausgabedatei.
  • WriteCompleteFromEmailAddress – schreibt die vollständige Absender‑E‑Mail‑Adresse in die Ausgabedatei.
  • WriteCompleteCcEmailAddress – schreibt die vollständigen E‑Mail‑Adressen aller CC‑Empfänger in die Ausgabedatei.
  • WriteCompleteBccEmailAddress – schreibt die vollständige E‑Mail‑Adresse aller BCC‑Empfänger in die Ausgabedatei.
  • RenderCalendarEvent – schreibt Text aus dem Kalenderevent in die Ausgabedatei.
  • SkipByteOrderMarkInBody – überspringen Sie die Byte‑Order‑Mark‑Bytes (BOM) im Body der Ausgabedatei.
  • RenderVCardInfo – schreibt Text aus VCard‑AlternativeView in die Ausgabedatei.
  • DisplayAsOutlook – zeigt die From‑Kopfzeile an.
  • RenderTaskFields – schreibt spezifische Aufgabenfelder in die Ausgabedatei.
  • None – Keine Einstellung angegeben.

Das folgende Code‑Snippet zeigt, wie EML‑Dateien mit optionalen Einstellungen in MHTML konvertiert werden.

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

Kalenderevents rendern

Die MhtFormatOptions.RenderCalendarEvent Rendert die Kalendereignisse zur Ausgabe MHTML. Der folgende Codeausschnitt zeigt, wie man Kalendereignisse beim Konvertieren nach MHTML rendert.

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

Exportieren von E‑Mails nach MHT ohne Inline‑Bilder

Die SkipInlineImages Eigenschaft des MhtSaveOptions Klasse definiert, ob Bildreferenzen beim Speichern nach MHTML übersprungen werden. Der Standardwert ist 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);

Exportieren einer E‑Mail nach MHT mit benutzerdefinierter Zeitzone

MailMessage class provides the TimeZoneOffset Eigenschaft zum Festlegen einer benutzerdefinierten Zeitzone beim Exportieren nach MHT. Das folgende Code‑Snippet zeigt, wie Sie E‑Mails nach MHT mit angepasster Zeitzone exportieren.

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

Schriftanpassung

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

EML nach HTML speichern

Die HtmlSaveOptions Klasse ermöglicht den Export des Nachrichtenkörpers nach HTML. Das folgende Code‑Snippet zeigt, wie Sie eine Nachricht als HTML speichern.

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

Steuern, wie Ressourcen gerendert werden

Die ResourceRenderingMode Eigenschaft des HtmlSaveOptions Klasse definiert, wie Nachrichtenressourcen (z. B. Inline‑Bilder) in das Ausgabe‑HTML geschrieben werden. Sie akzeptiert die Werte der ResourceRenderingMode Aufzählung:

  • EmbedIntoHtml – betten Sie die Ressourcen als Base64‑Zeichenfolgen in das HTML ein. Dies ist der Standardwert.
  • SaveToFile – speichern Sie die Ressourcen als Dateien und fügen Sie den Pfad jeder Datei in das src Tag.
  • SubstituteFromFile – verwenden Sie eine benutzerdefinierte Datei als Symbol und fügen Sie den Pfad dazu in das src Tag.
  • None – rendern Sie die Ressourcen nicht im HTML.

Wenn die Ressourcen nicht eingebettet sind, ist das SaveResourceHandler Delegierte wird für jeden Nachrichtenanhang aufgerufen, wodurch Sie entscheiden können, wo jede Ressource gespeichert wird und welcher Pfad in das HTML geschrieben wird.

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

EML nach OFT speichern

Das folgende Code‑Snippet zeigt, wie Sie eine Nachricht als Outlook‑Vorlage (.oft) speichern.

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

EML in MSG konvertieren (MailMessage zu MapiMessage)

Um ein MailMessage Objekt, das aus einer EML‑Datei geladen wurde, zu einem MapiMessage Objekt, verwenden Sie die MapiConversionOptions Klasse. Diese Konvertierung ist häufig erforderlich, weil diese beiden Objekte unterschiedliche Zwecke erfüllen und verschiedenen Anforderungen in der E‑Mail‑Verarbeitung gerecht werden. MapiMessage ist speziell für die Kompatibilität mit Microsoft Outlook und Exchange Server konzipiert, da es dem Messaging Application Programming Interface (MAPI)‑Format entspricht. Dies stellt sicher, dass in MSG‑Dateien konvertierte E‑Mails vollständig mit Microsoft‑Produkten kompatibel sind und direkt in Outlook geöffnet, bearbeitet und verwaltet werden können.

Diese Konvertierung ist ebenfalls erforderlich, wenn E‑Mails archiviert, indiziert oder von Speichersystemen verarbeitet werden müssen, die das MAPI‑Format, PST/OST, OLM‑Speicher usw. benötigen. Der MapiConversionOptions Klasse ermöglicht es Ihnen, zusätzliche Optionen festzulegen, wie das Beibehalten des ursprünglichen Nachrichtenformats, das Bewahren der Originaldaten und das Komprimieren des RTF‑Körpers während der Konvertierung. Das folgende Codebeispiel zeigt, wie eine E‑Mail aus einer Datei im .eml‑Format geladen und in das Outlook‑Format .msg konvertiert wird, wobei Anpassungen möglich sind, aber sichergestellt wird, dass bestimmte Merkmale der ursprünglichen E‑Mail während der Konvertierung erhalten bleiben.

  1. Erstellen Sie eine Instanz von MapiConversionOptions und seine Eigenschaften konfigurieren.
  2. Konvertiere das MailMessage Objekt zu einem MapiMessage Objekt unter Verwendung der konfigurierten Konvertierungsoptionen.
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);

Verfügbare Eigenschaften von MapiConversionOptions

  • ASCIIFormat: Gibt zurück MapiConversionOptions konfiguriert mit OutlookMessageFormat als ASCII, mit PreserveSignature auf false setzen und UseBodyCompression auf false setzen. Diese Option ist nützlich, wenn Sie eine reine ASCII-Formatkonvertierung benötigen.

  • UnicodeFormat: Gibt zurück MapiConversionOptions mit OutlookMessageFormat auf Unicode setzen, und sowohl PreserveSignature und UseBodyCompression auf false setzen. Verwenden Sie diese Option für umfassendere Zeichenunterstützung in MSG-Dateien.

  • ForcedRtfBodyForAppointment: Wenn auf true gesetzt, wird erzwungen, dass für Kalendertermine der RTF-Body verwendet wird. Dies ist nützlich, um die Kompatibilität mit bestimmten Mail‑Clients sicherzustellen. Standard ist true.

  • Format: Gibt das Ausgabeformat für die MSG-Datei an. Es kann entweder OutlookMessageFormat.ASCII oder OutlookMessageFormat.Unicode, steuert, ob die konvertierte MSG ASCII- oder Unicode‑Kodierung verwenden soll.

  • PreserveEmbeddedMessageFormat: Bestimmt, ob das ursprüngliche EML-Format eingebetteter Nachrichten bei der Konvertierung zu MapiMessage. Wenn dies auf true gesetzt wird, behalten eingebettete E‑Mails ihre ursprüngliche Struktur. Standard ist false.

  • PreserveEmptyDates: Wenn auf true gesetzt, werden die ursprünglichen Erstellungs‑ und Änderungsdaten aus dem EML beibehalten. Andernfalls werden neue Daten generiert, falls die originalen leer sind.

  • PreserveOriginalAddresses: Wenn auf true gesetzt, werden die ursprünglichen E‑Mail‑Adressen ohne Validierung beibehalten. Dies ist nützlich, wenn E‑Mail‑Adressen vorliegen, die nicht den strengen Standards entsprechen, aber unverändert erhalten bleiben müssen. Standard ist false.

  • PreserveOriginalDates: Stellt sicher, dass die ursprünglichen Sende- und Empfangsdatumsangaben während der Konvertierung erhalten bleiben. Wird dies auf true gesetzt, bleiben diese Daten für bessere historische Genauigkeit erhalten.

  • RemoveSignature: Steuert, ob die digitale Signatur, falls vorhanden, während der Konvertierung aus der Nachricht entfernt wird. Standard ist false, das heißt, die Signatur bleibt erhalten, sofern sie nicht ausdrücklich entfernt wird.

  • UseBodyCompression: Aktiviert die RTF-Body-Kompression, wenn auf true gesetzt. Dies kann die Größe der MSG-Datei reduzieren, besonders bei großen Nachrichten mit umfangreicher Formatierung.