Lesen und Konvertieren von Outlook-Dateien

Arbeiten mit OST-Dateien

Aspose.Email für .NET bietet eine API zum Lesen von Microsoft Outlook OST-Dateien. Sie können eine OST-Datei von einer Festplatte oder einem Stream in eine Instanz von Aspose.Email.Outlook.Pst.PersonalStorage Klasse zum Zugriff auf deren Inhalte, wie Ordner, Unterordner und Nachrichten. Microsoft Outlook erstellt eine PST-Datei, um E‑Mails zu speichern, wenn POP3‑ oder IMAP‑Mailserver verwendet werden. Im Gegensatz dazu wird eine OST‑Datei erstellt, wenn Microsoft Exchange der Mailserver ist. OST‑Dateien unterstützen außerdem größere Dateigrößen als PST‑Dateien.

OST-Dateien lesen

Der Vorgang zum Lesen einer OST‑Datei mit Aspose.Email ist identisch mit dem Lesen einer PST‑Datei. Derselbe Code kann sowohl PST‑ als auch OST‑Dateien lesen: Geben Sie einfach den korrekten Dateinamen an die PersonalStorage.FromFile() Methode. Das folgende Code‑Snippet zeigt, wie Sie OST‑Dateien lesen.

OST in PST konvertieren

Probieren Sie es aus!

E‑Mails & Nachrichtenarchive online mit dem kostenlosen Aspose.Email Konvertierungs‑App.

Aspose.Email ermöglicht das Konvertieren einer OST‑Datei in PST mit einer einzigen Code‑Zeile. Ebenso kann die OST‑Datei aus einer PST‑Datei mit derselben Code‑Zeile erstellt werden, indem man Dateiformat Enumerator. Derzeit unterstützt die API die Konvertierung von OST-Formaten zu PST außer 2013/2016/2019/2021 und zukünftigen Versionen. Der folgende Codeausschnitt zeigt, wie OST zu PST konvertiert wird.

Für weitere Vorgänge mit OST‑Dateien lesen Sie bitte die folgenden Seiten:

PST in OST konvertieren

Die Konvertierung von PST zu OST wird von Aspose.Email nicht unterstützt, da OST immer von Outlook erstellt wird, wenn ein Konto hinzugefügt und mit dem Mailserver synchronisiert wird. Der Unterschied zwischen PST‑ und OST‑Dateien besteht darin, dass PST nur lokal verfügbar ist. OST‑Inhalte sind ebenfalls auf dem E‑Mail‑Server verfügbar. Daher besteht kein Bedarf, PST für die lokale Nutzung in OST zu konvertieren. Sie können jedoch PST mithilfe des Import/Export‑Assistenten in Outlook in ein bestehendes Konto importieren.

OLM ist ein spezifisches Dateiformat, das von Microsoft Outlook zum Speichern lokaler Daten wie E‑Mails, Anhänge, Notizen, Kalenderdaten, Kontakte, Aufgaben, Verlauf und mehr verwendet wird. OLM‑Dateien sind nur mit Outlook für Mac kompatibel und können nicht von Outlook für Windows geöffnet oder darauf zugegriffen werden, das stattdessen das PST‑Dateiformat verwendet.

Arbeiten mit OLM‑Dateien

OLM‑Dateien öffnen

OLM‑Formatdateien können auf zwei Arten geöffnet werden:

unter Verwendung des Konstruktors
unter Verwendung der statischen FromFile‑Methode

Es gibt Verhaltensunterschiede zwischen diesen Methoden. Siehe den untenstehenden Abschnitt.

Verwendung des Konstruktors

Um eine Datei zu öffnen, rufen Sie den Konstruktor der OlmStorage Klasse und übergeben Sie den vollständigen Dateinamen oder Stream als Argument:

var fileName = "MyStorage.olm";
var olm = new OlmStorage(fileName);

Verwendung der statischen Methode FromFile

Um eine Datei zu öffnen, verwenden Sie die statische Methode FromFile und übergeben Sie den vollständigen Dateinamen oder Stream als Argument:

var fileName = "MyStorage.olm";
var olm = OlmStorage.FromFile(fileName);

Ordner abrufen

Um die Verzeichnisstruktur einer OLM‑Datei zuzugreifen, erstellen Sie eine Instanz von OlmStorage Klasse mit ihrem Konstruktor und übergeben Sie den Pfad zur Datei. Sobald die Datei geöffnet ist, greifen Sie auf ihre Verzeichnisstruktur zu, indem Sie die FolderHierarchy Eigenschaft zu. Diese Eigenschaft gibt eine Liste von OlmFolder Objekte, die jeweils ein Verzeichnis in der OLM‑Datei darstellen. Um die Verzeichnisstruktur weiter zu erkunden, greifen Sie auf das SubFolders Eigenschaft jedes Objekts, die eine Liste seiner Unterverzeichnisse zurückgibt. Durch die Verwendung dieser Eigenschaften können Sie die gesamte Verzeichnisstruktur der OLM‑Datei durchlaufen und auf alle darin enthaltenen Verzeichnisse und Unterverzeichnisse zugreifen.

Das folgende Beispiel zeigt die Liste aller Ordner in hierarchischer Reihenfolge:

using (var olm = new OlmStorage(fileName))
{
    PrintAllFolders(olm.FolderHierarchy, string.Empty);
}

private void PrintAllFolders(List<OlmFolder> folderHierarchy, string indent)
{
    foreach (var folder in folderHierarchy)
    {
        Console.WriteLine($"{indent}{folder.Name}");
        PrintAllFolders(folder.SubFolders, indent+"-");
    }
}

Beim Verwenden der FromFile Methode, um eine OLM‑Datei zu öffnen, die FolderHierarchy Eigenschaft wird standardmäßig nicht initialisiert und gibt null zurück. Rufen Sie in diesem Fall die GetFolders‑Methode explizit auf, um die FolderHierarchy Eigenschaft und die Liste der Verzeichnisse in der OLM‑Datei abrufen:

using (var olm = OlmStorage.FromFile(fileName))
{
    var folders = olm.GetFolders();
}

Außerdem ist es möglich, einen beliebigen Ordner anhand des Namens zu erhalten:

Rufen Sie GetFolder Methode.
Übergeben Sie den Ordnernamen als erstes Argument und den Wert, der angibt, ob bei der Ordnersuche die Groß‑/Kleinschreibung ignoriert werden soll, als zweiten Parameter.

using (var olm = OlmStorage.FromFile(fileName))
{
    // get inbox folder by name
    OlmFolder folder = olm.GetFolder("Inbox", true);
}

E‑Mails auflisten

OlmFolder Klasse, die einen Ordner darstellt, verfügt über die folgenden Methoden, um die Liste der E‑Mails abzurufen:

EnumerateMessages implementiert die Iteration von E‑Mails in einem Ordner. In diesem Fall gibt jede Iteration zurück OlmMessageInfo Objekt, das kurze Informationen über die E‑Mail bereitstellt.
EnumerateMapiMessages, implementiert zudem die Iteration von E‑Mails in einem Ordner, wobei in diesem Fall jede Iteration zurückgibt MapiMessage Objekt, das die E‑Mail selbst mit allen Eigenschaften darstellt.

Verwendung der EnumerateMessages-Methode

using (var olm = OlmStorage.FromFile(fileName))
{
    var folder = olm.GetFolder("Inbox", true);
    foreach (var messageInfo in folder.EnumerateMessages())
    {
        Console.WriteLine(messageInfo.Subject);
    }
}

Verwendung der EnumerateMapiMessages-Methode

using (var olm = OlmStorage.FromFile(fileName))
{
    var folder = olm.GetFolder("Inbox", true);

    foreach (var msg in folder.EnumerateMapiMessages())
    {
        // save message in MSG format
        msg.Save($"{msg.Subject}.msg");
    }
}

Weitere nützliche Eigenschaften

Die anderen nützlichen Eigenschaften der OlmFolder-Klasse sind: HasMessages und MessageCount Eigenschaften, die das Vorhandensein von Nachrichten im Ordner und deren Anzahl zurückgeben.

using (var olm = OlmStorage.FromFile(fileName))
{
    var folder = olm.GetFolder("Inbox", true);

    if (folder.HasMessages)
    {
        Console.WriteLine($"Message count: {folder.MessageCount}");
    }
}

Das Änderungsdatum einer Nachricht erhalten oder setzen

Das Änderungsdatum gibt das Datum und die Uhrzeit an, zu der die OLM‑Nachricht zuletzt geändert wurde. Sie können das OlmMessageInfo.ModifiedDate Eigenschaft, um das Änderungsdatum einer OLM‑Nachricht abzurufen oder zu aktualisieren.

Hier ein Beispiel, das die Verwendung der Eigenschaft demonstriert:

foreach (OlmMessageInfo messageInfo in inboxFolder.EnumerateMessages())
{
   DateTime modifiedDate = messageInfo.ModifiedDate;
}

E‑Mails und Elemente extrahieren

OlmStorage Klasse hat ExtractMapiMessage Methode, die das Extrahieren von E‑Mails ermöglicht. Diese Methode erhält ein OlmMessageInfo Objekt.

using (var olm = OlmStorage.FromFile(fileName))
{
    var folder = olm.GetFolder("Inbox", true);

    foreach (var messageInfo in folder.EnumerateMessages())
    {
        if (messageInfo.Date == DateTime.Today)
        {
            // Extracts today's messages form Inbox
            var msg = olm.ExtractMapiMessage(messageInfo);
        }
    }
}

Verwendung der Traversal‑API

Sie können alle Elemente aus einer Outlook‑OLM‑Datei so weit wie möglich extrahieren, ohne Ausnahmen zu werfen, selbst wenn einige Daten der Originaldatei beschädigt sind. Verwenden Sie dafür OlmStorage(TraversalExceptionsCallback callback) Konstruktor und Load(string fileName) Methode anstelle der FromFile‑Methode. Der Konstruktor ermöglicht die Definition einer Callback‑Methode.

using (var olm = new OlmStorage((exception, id) => { /* Exception handling  code. */ }))

Die Callback‑Methode stellt Lade‑ und Durchlauf‑Ausnahmen zur Verfügung.

Die Load Methode gibt ’true’ zurück, wenn die Datei erfolgreich geladen wurde und ein weiteres Durchlaufen möglich ist. Ist die Datei beschädigt und ein Durchlaufen nicht möglich, wird ‘false’ zurückgegeben.

if (olm.Load(fileName))

Das folgende Code‑Snippet und die Schritte zeigen, wie diese API verwendet wird:

Erstellen Sie eine neue Instanz von OlmStorage Klasse aufrufen und einen Callback zur Ausnahmebehandlung übergeben, um auftretende Ausnahmen während des Vorgangs zu behandeln.
Laden Sie die OLM-Datei, indem Sie die Load Methode der OlmStorage-Instanz.
Wenn die OLM-Datei erfolgreich geladen wurde, erhalten Sie die Ordnerhierarchie, indem Sie die GetFolders Methode auf der OlmStorage-Instanz. Diese gibt eine Liste von OlmFolder-Objekten zurück.
Rufen Sie die Methode ExtractItems auf und übergeben Sie die OlmStorage-Instanz sowie die Liste von OlmFolder-Objekten.
Iterieren Sie in der Methode ExtractItems durch jeden Ordner in der Ordnerliste.
Falls der Ordner Nachrichten (E‑Mails) enthält, geben Sie den Ordnernamen mit Console.WriteLine(folder) in der Konsole aus.
Durchlaufen Sie die Nachrichten im aktuellen Ordner, indem Sie die Methode EnumerateMessages auf der OlmStorage-Instanz aufrufen und den aktuellen Ordner als Argument übergeben.
Geben Sie den Betreff jeder Nachricht mit Console.WriteLine(msg.Subject) in der Konsole aus.
Wenn der Ordner Unterordner hat, rufen Sie die Methode ExtractItems rekursiv erneut auf und übergeben die OlmStorage-Instanz sowie die Unterordner des aktuellen Ordners.

using (var olm = new OlmStorage((exception, id) => { /* Exception handling  code. */ }))
{
    if (olm.Load(fileName))
    {
        var folderHierarchy = olm.GetFolders();
        ExtractItems(olm, folderHierarchy);
    }
}

private static void ExtractItems(OlmStorage olm, List<OlmFolder> folders)
{
    foreach (var folder in folders)
    {
        if (folder.HasMessages)
        {
            Console.WriteLine(folder);

            foreach (var msg in olm.EnumerateMessages(folder))
            {
                Console.WriteLine(msg.Subject);
            }
        }

        if (folder.SubFolders.Count > 0)
        {
            ExtractItems(olm, folder.SubFolders);
        }
    }
}

Nachrichten nach Kennungen extrahieren

Manchmal ist es erforderlich, ausgewählte Nachrichten anhand von Kennungen zu extrahieren. Beispielsweise speichert Ihre Anwendung Kennungen in einer Datenbank und ruft bei Bedarf eine Nachricht ab. Dies ist ein effizienter Weg, um das Durchsuchen des gesamten Speichers bei jeder Suche nach einer bestimmten Nachricht zu vermeiden. Diese Funktion ist für OLM‑Speicher verfügbar. Die EntryId Eigenschaft des OlmMessageInfo Klasse erhält die Nachrichten‑Entry‑ID. Die überladene ExtractMapiMessage(string id) Methode des OlmStorage Klasse ruft die Nachricht aus OLM ab.

Der nachstehende Code zeigt, wie Nachrichten aus OLM anhand von Kennungen extrahiert werden.

Der Code führt die folgenden Schritte aus:

Startet eine foreach‑Schleife, um durch eine Liste von OlmMessageInfo Objekte. Die Schleife verwendet die EnumerateMessages Methode des olmFolder‑Objekts aufruft, um eine Liste aller Nachrichten im aktuell durchlaufenen Ordner abzurufen.
Die Schleife extrahiert das entsprechende MapiMessage‑Objekt aus dem Speicher, indem sie die ExtractMapiMessage(string id) Methode von OlmStorage Klasse, wobei übergeben wird EntryId der aktuellen Nachricht als Parameter.

Das abgerufene MapiMessage‑Objekt kann verwendet werden, um auf den Inhalt der Nachricht zuzugreifen und diesen zu manipulieren. Die Schleife läuft weiter, bis alle Nachrichten im Ordner verarbeitet wurden.

  foreach (OlmMessageInfo msgInfo in olmFolder.EnumerateMessages())
  {
      MapiMessage msg = storage.ExtractMapiMessage(msgInfo.EntryId);
  }

Abruf des Ordnerpfads

Sie können auch den Ordnerpfad der Ordner in der OML‑Datei erhalten. Aspose.Email bietet OlmFolder.Path Eigenschaft, die den Ordnerpfad zurückgibt. Das folgende Code‑Snippet demonstriert die Verwendung von OlmFolder.Path Eigenschaft, um die Ordnerpfade in der OML‑Datei zu erhalten.

var storage = new OlmStorage("SampleOLM.olm");
PrintPath(storage, storage.FolderHierarchy);

public static void PrintPath(OlmStorage storage, List<OlmFolder> folders)
{
    foreach (OlmFolder folder in folders)
    {
        // print the current folder path
        Console.WriteLine(folder.Path);

        if (folder.SubFolders.Count > 0)
        {
            PrintPath(storage, folder.SubFolders);
        }
    }
}

Elemente im Ordner zählen

Sie können auch die Anzahl der Elemente im Ordner zählen. Aspose.Email bietet OlmFolder.MessageCount Eigenschaft, die die Anzahl der Elemente im Ordner zurückgibt. Das folgende Code‑Snippet demonstriert die Verwendung von OlmFolder.MessageCount Eigenschaft, um die Anzahl der Elemente in den Ordnern der OML‑Datei zu erhalten.

var storage = new OlmStorage("SampleOLM.olm");
PrintMessageCount(storage.FolderHierarchy);

public static void PrintMessageCount(List<OlmFolder> folders)
{
    foreach (OlmFolder folder in folders)
    {
        Console.WriteLine("Message Count [" + folder.Name + "]: " + folder.MessageCount);
    }
}

Gesamtanzahl der Elemente im OlmStorage abrufen

OlmStorage Klasse hat außerdem GetTotalItemsCount() Methode, die die Gesamtzahl der Nachrichtenobjekte im OLM‑Speicher zurückgibt.

  using (var olm = new OlmStorage("storage.olm"))
  {
     var count = olm.GetTotalItemsCount();
  }

Abruf von Outlook‑Kategorienfarben

Um mit Kategorienfarben oder Outlook‑Elementkategorien, die in OLM-Dateien gespeichert sind, zu arbeiten, bietet Aspose.Email die folgenden Lösungen an:

OlmItemCategory Klasse – repräsentiert Outlook‑Elementkategorien, die über ihren Namen und zugehörige Farben im hexadezimalen Format verfügbar sind.
GetCategories() Methode des OlmStorage Klasse – ruft die Kategorieliste ab.

Das folgende Codebeispiel demonstriert, wie alle verwendeten Kategorien aus dem OML‑Speicher abgerufen werden:

using (var olm = OlmStorage.FromFile("storage.olm"))
{
    var categories = olm.GetCategories();
    
    foreach (var category in categories)
    {
        Console.WriteLine($"Category name: {category.Name}");
        
        //Color is represented as a hexadecimal value: #rrggbb
        Console.WriteLine($"Category color: {category.Color}");
    }
}

Das folgende Codebeispiel zeigt, wie die Farbe einer Nachrichtenkategorie ermittelt wird:

foreach (var msg in olm.EnumerateMessages(folder))
{
    if (msg.Categories != null)
    {
        foreach (var msgCategory in msg.Categories)
        {
            Console.WriteLine($"Category name: {msgCategory}");
            var categoryColor = cat.First(c => c.Name.Equals(msgCategory, StringComparison.OrdinalIgnoreCase)).Color;
            Console.WriteLine($"Category color: {categoryColor}");
        }
    }
}

OLM in PST konvertieren

OLM ist ein Datenbankdateiformat, das von Microsoft Outlook für Mac verwendet wird. OLM-Dateien speichern E‑Mail‑Nachrichten, Kalenderdaten, Kontaktdaten und Anwendungseinstellungen. Eine OLM-Datei wird von Outlook für Windows nicht unterstützt. Daher ist es nicht möglich, eine Outlook‑für‑Mac‑(OLM‑)Datei in Outlook für Windows zu öffnen. Wenn Sie Ihr Postfach von Outlook für Mac zu Outlook für Windows migrieren möchten, muss die OLM‑Datei von Outlook für Mac in das Outlook‑PST‑Dateiformat konvertiert werden.

Code‑Schritte

Um eine OLM-Datei zu PST zu konvertieren, befolgen Sie die nachstehenden Schritte:

Erstellen Sie eine Instanz von OlmStorage Klasse zum Öffnen der Quell‑OLM.
Öffnen Sie eine Quell‑OLM-Datei.
Erstellen Sie eine neue PST-Datei mit Erstellen Methode.
Erstellen Sie eine GetContainerClass‑Methode, um die Nachrichtenklasse einer Ordnerklasse zuzuordnen.
Erstellen Sie eine AddToPst-Methode, die jedes Ordner und dessen Nachrichten rekursiv aus OLM mithilfe der EnumerateMapiMessages‑Methode liest und sie in derselben Reihenfolge mit den Methoden AddSubFolder und AddMessage zur PST hinzufügt.

Codebeispiel

Das folgende Codebeispiel zeigt, wie OLM zu PST konvertiert wird.

Main-Methode:

// create an instance of OlmStorage class to open source OLM
using (var olm = new OlmStorage("my.olm"))
// create a new PST file
using (var pst = PersonalStorage.Create("my.pst", FileFormatVersion.Unicode))
{
    // recursively reads each folder and its messages 
    // and adds them to the PST in the same order
    foreach (var olmFolder in olm.FolderHierarchy)
    {
        AddToPst(pst.RootFolder, olmFolder);
    }
}

GetContainerClass-Methodenimplementierung:

public string GetContainerClass(string messageClass)
{
    if (messageClass.StartsWith("IPM.Contact") || messageClass.StartsWith("IPM.DistList"))
    {
        return "IPF.Contact";
    }

    if (messageClass.StartsWith("IPM.StickyNote"))
    {
        return "IPF.StickyNote";
    }

    if (messageClass.StartsWith("IPM.Activity"))
    {
        return "IPF.Journal";
    }

    if (messageClass.StartsWith("IPM.Task"))
    {
        return "IPF.Task";
    }

    if (messageClass.StartsWith("IPM.Appointment") || messageClass.StartsWith("IPM.Schedule.meeting"))
    {
        return "IPF.Appointment";
    }

    return "IPF.Note";
}

AddToPst-Methodenimplementierung:

public void AddToPst(FolderInfo pstFolder, OlmFolder olmFolder)
{
    FolderInfo pstSubFolder = pstFolder.GetSubFolder(olmFolder.Name);

    foreach (var msg in olmFolder.EnumerateMapiMessages())
    {
        if (pstSubFolder == null)
        {
            pstSubFolder = pstFolder.AddSubFolder(olmFolder.Name, GetContainerClass(msg.MessageClass));
        }

        pstSubFolder.AddMessage(msg);
    }

    if (pstSubFolder == null)
    {

        pstSubFolder = pstFolder.AddSubFolder(olmFolder.Name);
    }

    foreach (var olmSubFolder in olmFolder.SubFolders)
    {
        AddToPst(pstSubFolder, olmSubFolder);
    }
}

Arbeiten mit großen PST‑Dateien