Documentation – Arbeiten mit OLM-Dateien

Net: OLM‑Dateien öffnen

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Email für .NET stellt eine Outlook‑for‑Mac‑Speicherdatei dar mit der OlmStorage Klasse. Dieser Artikel zeigt, wie man eine OLM‑Datei von einem Pfad oder Stream öffnet und wie man eine möglicherweise beschädigte Datei sicher lädt.

Öffnen einer OLM‑Datei

Eine OLM‑Datei kann auf zwei Arten geöffnet werden:

Verwendung eines Konstruktors;
Verwendung der statischen FromFile Methode.

Es gibt einen Unterschied im Verhalten dieser beiden Ansätze, der beeinflusst, wie die Ordnerhierarchie initialisiert wird. Siehe Durch OLM‑Ordner navigieren für weitere Details.

Verwendung des Konstruktors

Um eine Datei zu öffnen, rufen Sie den Konstruktor der OlmStorage Klasse und übergeben den vollständigen Dateinamen als Argument. Da OlmStorage implementiert IDisposable, wickeln Sie sie in ein using Anweisung, damit der zugrundeliegende Datei‑Handle freigegeben wird, wenn Sie fertig sind.

var fileName = "MyStorage.olm";
using (var olm = new OlmStorage(fileName))
{
    // work with the storage
}

Verwendung der statischen FromFile‑Methode

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

var fileName = "MyStorage.olm";
using (var olm = OlmStorage.FromFile(fileName))
{
    // work with the storage
}

Öffnen einer OLM‑Datei aus einem Stream

Wenn die OLM‑Daten nicht von einem lokalen Pfad stammen – zum Beispiel, weil sie aus einer Datenbank, einer Netzwerkressource oder einem Cloud‑Speicher kommen – können Sie sie direkt aus einem Stream. Verwenden Sie die OlmStorage(Stream) Konstruktor oder die statische FromStream Methode.

using (var stream = File.OpenRead("MyStorage.olm"))
using (var olm = new OlmStorage(stream))
{
    // work with the storage
}

Die statische Methode funktioniert identisch:

using (var stream = File.OpenRead("MyStorage.olm"))
using (var olm = OlmStorage.FromStream(stream))
{
    // work with the storage
}

Halten Sie den Quell‑Stream so lange offen, wie Sie auf den Speicher zugreifen. Das Freigeben des Streams, bevor Sie Ordner und Nachrichten gelesen haben, führt zu Lesefehlern.

Öffnen einer beschädigten OLM‑Datei

Wenn eine Datei teilweise beschädigt sein könnte, können Sie trotzdem so viele Daten wie möglich extrahieren, ohne beim ersten Fehler anzuhalten. Erzeugen Sie dafür OlmStorage Instanz mit dem OlmStorage(TraversalExceptionsCallback callback) Konstruktor, dann laden Sie die Datei mit der Load Methode statt FromFile.

Der Callback erhält die während des Ladens und Durchlaufens ausgelösten Ausnahmen, sodass Sie diese protokollieren oder ignorieren können. Die Load Methode gibt true wenn die Datei erfolgreich geladen wurde und Traversierung möglich ist, und false falls die Datei zu stark beschädigt ist, um sie zu durchlaufen.

using (var olm = new OlmStorage((exception, id) =>
{
    // Exception handling code.
    Console.WriteLine($"Failed to process item '{id}': {exception.Message}");
}))
{
    if (olm.Load(fileName))
    {
        // The file was loaded and can be traversed.
        var folderHierarchy = olm.GetFolders();
    }
    else
    {
        Console.WriteLine("The OLM file is corrupted and cannot be traversed.");
    }
}

Für ein vollständiges Beispiel zum Extrahieren von Elementen aus einer beschädigten Datei, siehe OLM‑Nachrichten lesen und extrahieren.

Net: Durch OLM‑Ordner navigieren

Mon, 01 Jan 0001 00:00:00 +0000

Eine OLM‑Datei organisiert ihre Daten in einem Baum von Ordnern, die jeweils durch ein OlmFolder Objekt darauf zu. Dieser Artikel zeigt, wie man die Ordnerhierarchie aufzählt, einen bestimmten Ordner nach Namen abruft, Unterordner navigiert und Ordnerpfade liest.

Ordnerhierarchie abrufen

Nachdem eine Datei geöffnet ist, greifen Sie über die FolderHierarchy Eigenschaft zu. Diese Eigenschaft gibt eine Liste von OlmFolder Objekte, von denen jedes ein Top‑Level‑Verzeichnis in der OLM‑Datei darstellt. Um tiefer zu gehen, lesen Sie die SubFolders Eigenschaft jedes Ordners, die seine Unterverzeichnisse zurückgibt. Mit diesen beiden Mitgliedern können Sie die gesamte Hierarchie durchlaufen.

Das nachstehende Beispiel druckt alle Ordner in hierarchischer Reihenfolge:

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

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

FolderHierarchy und die FromFile‑Methode

Die Art, wie Sie die Datei öffnen, beeinflusst, wie FolderHierarchy :

Wenn Sie die Datei über den Konstruktor öffnen, verhält sich die FolderHierarchy Eigenschaft öffnen, wird sie automatisch initialisiert.
Wenn Sie die Datei mit dem FromFile Methode, FolderHierarchy ist nicht standardmäßig initialisiert und gibt null. In diesem Fall rufen Sie die GetFolders Methode explizit auf, um die Hierarchie zu initialisieren und die Verzeichnisliste abzurufen:

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

Get a Folder by Name

Um einen einzelnen Ordner nach Namen abzurufen, rufen Sie die GetFolder Methode. Übergeben Sie den Ordnernamen als erstes Argument und ein Boolesches als zweites Argument, das angibt, ob die Groß‑/Kleinschreibung bei der Suche ignoriert werden soll.

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

Einen Unterordner nach Namen erhalten

Jedes OlmFolder ermöglicht Ihnen außerdem, einen Unterordner direkt mit dem GetSubFolder Methode. Übergeben Sie den Unterordnernamen und ob die Groß‑/Kleinschreibung ignoriert werden soll. Das ist nützlich, wenn Sie bereits einen übergeordneten Ordner besitzen und ohne erneutes Durchsuchen der gesamten Hierarchie tiefer einsteigen möchten.

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

    // get a sub-folder of Inbox by name
    OlmFolder archive = inbox.GetSubFolder("Archive", true);

    if (archive != null)
    {
        Console.WriteLine($"Found sub-folder: {archive.Name}");
    }
}

Ordnerpfade abrufen

Sie können den vollständigen Pfad eines beliebigen Ordners über die OlmFolder.Path Eigenschaft. Der folgende Ausschnitt gibt den Pfad jedes Ordners in der Datei aus:

using (var storage = new OlmStorage("SampleOLM.olm"))
{
    PrintPath(storage.FolderHierarchy);
}

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

        PrintPath(folder.SubFolders);
    }
}

Net: OLM‑Nachrichten lesen und extrahieren

Mon, 01 Jan 0001 00:00:00 +0000

Nachdem Sie eine OLM‑Datei geöffnet und einen Ordner gefunden haben, können Sie dessen Nachrichten auflisten, Kurzinfos lesen, große Ordner filtern und paginieren sowie einzelne Nachrichten extrahieren als MapiMessage Objekte. Dieser Artikel behandelt all diese Vorgänge.

Nachrichten in einem Ordner auflisten

Die OlmFolder Klasse bietet zwei Möglichkeiten, über die darin enthaltenen Nachrichten zu iterieren:

EnumerateMessages liefert ein OlmMessageInfo Objekt bei jeder Iteration. Dieses Objekt enthält Kurzinformationen über die Nachricht und ist die effizienteste Methode, um einen Ordner zu durchsuchen.
EnumerateMapiMessages liefert ein volles MapiMessage Objekt bei jeder Iteration, wobei alle Eigenschaften der Nachricht geladen wurden.

Verwendung von EnumerateMessages

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

Verwendung von EnumerateMapiMessages

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

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

Nachrichteninformationen lesen

Jedes OlmMessageInfo Objekt stellt ein Satz schreibgeschützter Eigenschaften bereit, die eine Nachricht beschreiben, ohne deren vollständigen Inhalt zu laden. Dies ist der effizienteste Weg, um eine Listenansicht zu erstellen oder zu entscheiden, welche Nachrichten extrahiert werden sollen.

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

    foreach (OlmMessageInfo messageInfo in folder.EnumerateMessages())
    {
        Console.WriteLine($"Subject: {messageInfo.Subject}");
        Console.WriteLine($"From: {messageInfo.From}");
        Console.WriteLine($"To: {string.Join("; ", messageInfo.To)}");
        Console.WriteLine($"Date: {messageInfo.Date}");
        Console.WriteLine($"Modified: {messageInfo.ModifiedDate}");
        Console.WriteLine($"Has attachments: {messageInfo.HasAttachments}");
        Console.WriteLine($"Message class: {messageInfo.MessageClass}");
        Console.WriteLine(new string('-', 30));
    }
}

Das Änderungsdatum einer Nachricht erhalten

Das Änderungsdatum repräsentiert das Datum und die Uhrzeit, wann die OLM‑Nachricht zuletzt geändert wurde. Verwenden Sie die OlmMessageInfo.ModifiedDate Eigenschaft, um sie zu lesen:

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

Nachrichten mit einer Abfrage filtern

Bei großen Ordnern können Sie nur die Nachrichten abrufen, die einer Menge von Kriterien entsprechen, anstatt alles zu durchlaufen. Übergeben Sie eine MailQuery zum EnumerateMessages(MailQuery query) überladene. Erstellen Sie die Abfrage mit einem MailQueryBuilder.

Das nachstehende Beispiel listet nur die Nachrichten der letzten sieben Tage auf, deren Betreff das Wort "Rechnung" enthält:

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

    var builder = new MailQueryBuilder();
    builder.InternalDate.Since(DateTime.Now.AddDays(-7));
    builder.Subject.Contains("Invoice");
    MailQuery query = builder.GetQuery();

    foreach (var messageInfo in folder.EnumerateMessages(query))
    {
        Console.WriteLine(messageInfo.Subject);
    }
}

Durch Seiten blättern

Wenn ein Ordner eine große Anzahl von Nachrichten enthält, können Sie diese in Chargen mit der EnumerateMessages(int skip, int count) überladene. Die skip Parameter ist die Anzahl der zu überspringenden Nachrichten, und count ist die Anzahl der zurückzugebenden Nachrichten.

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

    const int pageSize = 50;
    int pageIndex = 0;

    while (true)
    {
        var page = folder.EnumerateMessages(pageIndex * pageSize, pageSize).ToList();
        if (page.Count == 0)
        {
            break;
        }

        foreach (var messageInfo in page)
        {
            Console.WriteLine(messageInfo.Subject);
        }

        pageIndex++;
    }
}

Eine Nachricht als MapiMessage extrahieren

Die OlmStorage class provides the ExtractMapiMessage Methode durchsuchen, die eine vollständige MapiMessage aus einem OlmMessageInfo Objekt. Das ist nützlich, wenn Sie zuerst einen Ordner mit EnumerateMessages und dann nur die Nachrichten extrahieren, die Sie tatsächlich benötigen.

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

    foreach (var messageInfo in folder.EnumerateMessages())
    {
        if (messageInfo.Date.Date == DateTime.Today)
        {
            // extract today's messages from Inbox
            var msg = olm.ExtractMapiMessage(messageInfo);
            msg.Save($"{msg.Subject}.msg");
        }
    }
}

Nachrichten nach Kennung extrahieren

Manchmal müssen Sie ausgewählte Nachrichten anhand ihrer Kennungen extrahieren. Zum Beispiel kann eine Anwendung Kennungen in einer Datenbank speichern und eine Nachricht bei Bedarf extrahieren, anstatt jedes Mal den gesamten Speicher zu durchlaufen. Die EntryId Eigenschaft von OlmMessageInfo liefert die Nachrichten‑Eintrags‑Kennung und die überladene ExtractMapiMessage(string id) Methode ruft die Nachricht anhand dieser Kennung ab.

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

    foreach (OlmMessageInfo msgInfo in olmFolder.EnumerateMessages())
    {
        // store msgInfo.EntryId somewhere, then later:
        MapiMessage msg = olm.ExtractMapiMessage(msgInfo.EntryId);
    }
}

Elemente mithilfe der Traversal‑API extrahieren

Sie können jedes Element aus einer OLM‑Datei extrahieren – soweit möglich – ohne Ausnahmen zu werfen, selbst wenn einige Daten in der Originaldatei beschädigt sind. Erstellen Sie dazu die OlmStorage Instanz mit dem OlmStorage(TraversalExceptionsCallback callback) Konstruktor und laden Sie die Datei mit dem Load Methode zurück. Der Callback stellt die Lade‑ und Traversierungs‑Ausnahmen bereit.

Die Load Methode gibt true wenn die Datei erfolgreich geladen wurde und Traversierung möglich ist, und false wenn die Datei beschädigt ist und keine Traversierung möglich ist. Beachten Sie, dass Sie beim traversieren der Elemente Ordner für Ordner die EnumerateMessages(OlmFolder folder) Methode, wobei der Ordner als Argument übergeben wird.

Die Schritte sind:

Erstellen Sie ein neues OlmStorage Instanz aufrufen und einen Callback für die Ausnahmebehandlung übergeben.
Laden Sie die OLM-Datei, indem Sie die Load Methode.
Falls die Datei erfolgreich geladen wird, erhalten Sie die Ordnerhierarchie, indem Sie GetFolders.
Rekursives Durchlaufen jedes Ordners. Für Ordner, die Nachrichten enthalten, zählen Sie diese mit der EnumerateMessages Methode und verarbeiten jeden einzelnen.
Rekursives Durchlaufen aller Unterordner.

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, IEnumerable<OlmFolder> folders)
{
    foreach (var folder in folders)
    {
        if (folder.HasMessages)
        {
            Console.WriteLine(folder);

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

        ExtractItems(olm, folder.SubFolders);
    }
}

Net: Elemente zählen und mit Kategorien arbeiten

Mon, 01 Jan 0001 00:00:00 +0000

Neben dem Lesen einzelner Nachrichten ermöglicht Aspose.Email für .NET Ihnen, zu prüfen, wie viele Elemente eine OLM‑Datei oder ein Ordner enthält, und die Outlook‑Kategorien – einschließlich ihrer Farben – zu lesen, die in der Datei gespeichert sind. Dieser Artikel behandelt beides.

Prüfen, ob ein Ordner Nachrichten enthält

Die OlmFolder.HasMessages Eigenschaft gibt an, ob ein Ordner Nachrichten enthält, und die OlmFolder.MessageCount Eigenschaft liefert die Anzahl.

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

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

Elemente in jedem Ordner zählen

Verwenden Sie die OlmFolder.MessageCount Eigenschaft, die die Anzahl der Elemente in jedem Ordner der Datei meldet:

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

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

        PrintMessageCount(folder.SubFolders);
    }
}

Ermitteln der Gesamtzahl der Elemente im Speicher

Die OlmStorage Klasse verfügt über ein GetTotalItemsCount() Methode, die die Gesamtzahl der Nachrichtenobjekte im gesamten OLM‑Speicher zurückgibt:

using (var olm = new OlmStorage("storage.olm"))
{
    var count = olm.GetTotalItemsCount();
    Console.WriteLine($"Total items: {count}");
}

Outlook‑Kategorienfarben abrufen

Um mit den in einer OLM‑Datei gespeicherten Outlook‑Element‑Kategorien zu arbeiten, bietet Aspose.Email:

die OlmItemCategory Klasse – stellt eine Outlook‑Element‑Kategorie dar, verfügbar über deren Name und zugehörige Farbe, dargestellt im hexadezimalen Format;
die GetCategories() Methode des OlmStorage Klasse – ruft die Liste der im Speicher verwendeten Kategorien ab.

Das folgende Beispiel listet jede im Speicher verwendete Kategorie zusammen mit ihrer Farbe auf:

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

Abrufen der Kategorienfarbe einer Nachricht

Sie können die Kategorien einer bestimmten Nachricht mit der Kategorieliste des Speichers abgleichen, um die Farbe jeder Kategorie zu ermitteln. Das Beispiel unten liest die Kategorien jeder Nachricht in einem Ordner und gibt die Farbe jeder einzelnen aus:

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

    foreach (var msg in folder.EnumerateMapiMessages())
    {
        if (msg.Categories != null)
        {
            foreach (var msgCategory in msg.Categories)
            {
                Console.WriteLine($"Category name: {msgCategory}");

                var category = categories
                    .FirstOrDefault(c => c.Name.Equals(msgCategory, StringComparison.OrdinalIgnoreCase));

                Console.WriteLine(category != null
                    ? $"Category color: {category.Color}"
                    : "Category color: Not found");
            }
        }
    }
}

Net: Umwandlung von OLM nach PST

Mon, 01 Jan 0001 00:00:00 +0000

OLM ist ein Datenbankdateiformat, das von Microsoft Outlook für Mac verwendet wird. OLM‑Dateien speichern E‑Mails, Kalenderdaten, Kontakte und Anwendungseinstellungen und werden von Outlook für Windows nicht unterstützt. Um ein Postfach von Outlook für Mac nach Outlook für Windows zu migrieren, müssen Sie die OLM‑Datei in das Outlook PST Format. Aspose.Email für .NET ermöglicht dies im Code, ohne dass Microsoft Outlook installiert sein muss.

Wie die Konvertierung funktioniert

Um eine OLM‑Datei in PST zu konvertieren, gehen Sie wie folgt vor:

Erstellen Sie eine Instanz von dem OlmStorage Klasse zum Öffnen der Quell-OLM-Datei.
Erstellen Sie eine neue PST-Datei mit dem PersonalStorage.Create Methode.
Implementieren Sie ein GetContainerClass Methode, die eine Nachrichtenklasse der entsprechenden Ordner‑(Container‑)Klasse zuordnet, sodass jeder Ordner im PST mit dem korrekten Typ erzeugt wird.
Implementieren Sie ein AddToPst Methode verwendet wird, die rekursiv jeden Ordner und seine Nachrichten aus der OLM‑Datei liest – mit EnumerateMapiMessages - und fügt sie in derselben Reihenfolge zum PST hinzu, wobei die AddSubFolder und AddMessage Methoden von FolderInfo.

Code‑Beispiel

Der folgende Code zeigt, wie man eine OLM‑Datei in PST konvertiert.

Main-Methode:

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

GetContainerClass‑Methode:

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‑Methode repräsentiert:

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

Die Umwandlung in die entgegengesetzte Richtung (PST zu OLM) wird nicht unterstützt, da eine OLM‑Datei immer von Outlook für Mac erstellt wird, wenn ein Konto hinzugefügt und mit dem Mail‑Server synchronisiert wird.