Documentation – Praca z plikami OLM

Net: Otwieranie plików OLM

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

Aspose.Email dla .NET reprezentuje plik przechowywania Outlook dla Mac za pomocą OlmStorage klasa. Ten artykuł pokazuje, jak otworzyć plik OLM z ścieżki lub strumienia oraz jak bezpiecznie ładować plik, który może być uszkodzony.

Otwórz plik OLM

Plik OLM można otworzyć na dwa sposoby:

używając konstruktora;
używając statycznego FromFile metoda.

Istnieje różnica w zachowaniu między tymi dwoma podejściami, która wpływa na inicjalizację hierarchii folderów. Zobacz Nawigacja po folderach OLM po szczegóły.

Używanie konstruktora

Aby otworzyć plik, wywołaj konstruktor OlmStorage klasę i przekazać pełną nazwę pliku jako argument. Ponieważ OlmStorage implementuje IDisposable, umieść go w using instrukcji, aby uchwyt do pliku został zwolniony po zakończeniu pracy.

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

Używanie statycznej metody FromFile

Aby otworzyć plik, użyj statycznego FromFile metody i przekazać pełną nazwę pliku jako argument:

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

Otwórz plik OLM ze strumienia

Gdy dane OLM nie pochodzą ze ścieżki lokalnej – na przykład są pobierane z bazy danych, zasobu sieciowego lub przechowywania w chmurze – możesz otworzyć je bezpośrednio z Stream. Użyj OlmStorage(Stream) konstruktor lub statyczny FromStream metoda.

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

Statyczna metoda działa w ten sam sposób:

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

Utrzymuj otwarty strumień źródłowy tak długo, jak korzystasz z magazynu. Zamykanie strumienia przed zakończeniem odczytu folderów i wiadomości spowoduje błędy odczytu.

Otwórz uszkodzony plik OLM

Jeśli plik może być częściowo uszkodzony, nadal możesz wyodrębnić jak najwięcej danych bez zatrzymywania się na pierwszym błędzie. W tym celu utwórz OlmStorage instancji z OlmStorage(TraversalExceptionsCallback callback) konstruktora, a następnie załaduj plik przy użyciu Load zamiast FromFile.

Wywołanie zwrotne otrzymuje wyjątki podnoszone podczas ładowania i przeglądania, więc możesz je zalogować lub zignorować. Metoda Load metoda zwraca true jeśli plik został załadowany pomyślnie i przeszukiwanie jest możliwe, oraz false jeśli plik jest zbyt uszkodzony, aby go przeglądać.

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

Pełen przykład wyodrębniania elementów z uszkodzonego pliku znajdziesz w Odczytywanie i wyodrębnianie wiadomości OLM.

Net: Nawigacja po folderach OLM

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

Plik OLM organizuje dane w drzewo folderów, z których każdy jest reprezentowany przez OlmFolder obiekt. Ten artykuł pokazuje, jak wyliczyć hierarchię folderów, pobrać konkretny folder po nazwie, nawigować po podfolderach i odczytać ścieżki folderów.

Pobierz hierarchię folderów

Po otwarciu pliku uzyskaj dostęp do jego struktury katalogów poprzez FolderHierarchy właściwość. Ta właściwość zwraca listę OlmFolder obiekty, każdy reprezentujący katalog najwyższego poziomu w pliku OLM. Aby zagłębić się dalej, przeczytaj SubFolders właściwość każdego folderu, która zwraca jego podkatalogi. Korzystając z tych dwóch członków, możesz przejść całą hierarchię.

Poniższy przykład drukuje wszystkie foldery w kolejności hierarchicznej:

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 i metoda FromFile

Sposób otwarcia pliku wpływa na to, jak FolderHierarchy zachowuje się:

Kiedy otwierasz plik przy użyciu konstruktora, FolderHierarchy właściwość jest inicjalizowana automatycznie.
Kiedy otwierasz plik przy użyciu FromFile metoda, FolderHierarchy nie jest inicjalizowane domyślnie i zwraca null. W tym przypadku wywołaj GetFolders metodę wyraźnie, aby zainicjować hierarchię i pobrać listę katalogów:

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

Pobierz folder po nazwie

Aby pobrać pojedynczy folder po nazwie, wywołaj GetFolder metodę. Przekaż nazwę folderu jako pierwszy argument oraz wartość boolowską jako drugi argument wskazującą, czy podczas wyszukiwania ma być ignorowana wielkość liter.

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

Pobierz podfolder po nazwie

Każdy OlmFolder pozwala także bezpośrednio zlokalizować podfolder przy użyciu GetSubFolder metodę. Przekaż nazwę podfolderu i informację, czy ma być ignorowana wielkość liter. Jest to przydatne, gdy już posiadasz folder nadrzędny i chcesz zagłębić się dalej bez ponownego skanowania całej hierarchii.

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

Pobieranie ścieżek folderów

Pełną ścieżkę dowolnego folderu można odczytać poprzez OlmFolder.Path właściwość. Poniższy fragment drukuje ścieżkę każdego folderu w pliku:

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: Odczytywanie i wyodrębnianie wiadomości OLM

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

Po otwarciu pliku OLM i zlokalizowaniu folderu, możesz wyświetlić jego wiadomości, odczytać krótkie informacje o wiadomościach, filtrować i stronicować duże foldery oraz wyodrębnić poszczególne wiadomości jako MapiMessage obiekty. Ten artykuł obejmuje wszystkie te operacje.

Lista wiadomości w folderze

Ten OlmFolder klasa udostępnia dwa sposoby iteracji po wiadomościach, które zawiera:

EnumerateMessages zwraca OlmMessageInfo obiekt przy każdej iteracji. Ten obiekt zawiera krótkie informacje o wiadomości i jest najwydajniejszym sposobem skanowania folderu.
EnumerateMapiMessages zwraca pełny MapiMessage obiekt przy każdej iteracji, ze wszystkimi właściwościami wiadomości załadowanymi.

Używanie EnumerateMessages

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

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

Odczyt informacji o wiadomości

Każdy OlmMessageInfo obiekt udostępnia zestaw właściwości tylko do odczytu opisujących wiadomość bez ładowania jej pełnej zawartości. To najwydajniejszy sposób budowania widoku listy lub decydowania, które wiadomości wyodrębnić.

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

Pobierz zmodyfikowaną datę wiadomości

Zmodyfikowana data reprezentuje datę i godzinę ostatniej modyfikacji wiadomości OLM. Użyj OlmMessageInfo.ModifiedDate właściwość, aby ją odczytać:

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

Filtrowanie wiadomości zapytaniem

Dla dużych folderów możesz pobrać tylko wiadomości spełniające określone kryteria zamiast iterować po wszystkich. Przekaż MailQuery do EnumerateMessages(MailQuery query) przeciążenie. Zbuduj zapytanie przy użyciu MailQueryBuilder.

Poniższy przykład wylicza jedynie wiadomości odebrane w ciągu ostatnich siedmiu dni, których temat zawiera słowo „Invoice”:

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

Stronicowanie wiadomości

Kiedy folder zawiera dużą liczbę wiadomości, możesz odczytywać je partiami przy użyciu EnumerateMessages(int skip, int count) przeciążenie. skip parametr to liczba wiadomości do pominięcia, a count to liczba wiadomości do zwrócenia.

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

Wyodrębnij wiadomość jako MapiMessage

Ten OlmStorage klasa udostępnia ExtractMapiMessage metoda, która wyodrębnia pełny MapiMessage z OlmMessageInfo obiekt. Jest to przydatne, gdy najpierw skanujesz folder przy użyciu EnumerateMessages i wtedy wyodrębnić tylko te wiadomości, które faktycznie są potrzebne.

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

Wyodrębnianie wiadomości według identyfikatora

Czasami trzeba wyodrębnić wybrane wiadomości według ich identyfikatorów. Na przykład aplikacja może przechowywać identyfikatory w bazie danych i wyodrębniać wiadomość na żądanie zamiast przeszukiwać całe magazynowanie przy każdej operacji. EntryId właściwość OlmMessageInfo udostępnia identyfikator wpisu wiadomości oraz przeciążona ExtractMapiMessage(string id) metoda pobiera wiadomość według tego identyfikatora.

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

Wyodrębnianie elementów przy użyciu API przeszukiwania

Możesz wyodrębnić każdy element z pliku OLM – w miarę możliwości – bez rzucania wyjątków, nawet gdy niektóre dane w oryginalnym pliku są uszkodzone. Aby to zrobić, utwórz OlmStorage instancji z OlmStorage(TraversalExceptionsCallback callback) konstruktor i wczytaj plik przy użyciu Load metodę. Funkcja zwrotna udostępnia wyjątki ładowania i przeszukiwania.

Ten Load metoda zwraca true jeśli plik został załadowany pomyślnie i przeszukiwanie jest możliwe, oraz false jeśli plik jest uszkodzony i nie można go przeszukać. Zauważ, że przy przeglądaniu elementów folder po folderze wywołujesz metodę magazynu EnumerateMessages(OlmFolder folder) metodę, przekazując folder jako argument.

Kroki są następujące:

Utwórz nowy OlmStorage instancję, przekazując funkcję zwrotną obsługującą wyjątki.
Załaduj plik OLM, wywołując Load metoda.
Jeśli plik załaduje się pomyślnie, uzyskaj hierarchię folderów wywołując GetFolders.
Rekurencyjnie iteruj po każdym folderze. Dla folderów zawierających wiadomości wylicz je przy użyciu metody magazynu EnumerateMessages metodę i przetwarzaj każdy z nich.
Rekurencyjnie przeglądaj wszystkie podfoldery.

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: Liczenie elementów i praca z kategoriami

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

Poza odczytem pojedynczych wiadomości, Aspose.Email dla .NET umożliwia sprawdzenie, ile elementów zawiera plik OLM lub folder oraz odczytanie kategorii Outlook – w tym ich kolorów – które są przechowywane w pliku. Ten artykuł obejmuje oba zagadnienia.

Sprawdź, czy folder ma wiadomości

Ten OlmFolder.HasMessages właściwość wskazuje, czy folder zawiera jakiekolwiek wiadomości, oraz OlmFolder.MessageCount właściwość zwraca ile jest.

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

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

Policz elementy w każdym folderze

Użyj OlmFolder.MessageCount właściwość raportującą liczbę elementów w każdym folderze pliku:

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

Pobierz łączną liczbę elementów w magazynie

Ten OlmStorage klasa ma GetTotalItemsCount() metodę, która zwraca łączną liczbę elementów wiadomości zawartych w całym magazynie OLM:

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

Pobieranie kolorów kategorii Outlook

Aby pracować z kategoriami elementów Outlook przechowywanymi w pliku OLM, Aspose.Email oferuje:

to OlmItemCategory klasa – reprezentuje kategorię elementu Outlook, dostępną przez jej Name i powiązane Kolor, reprezentowane w formacie szesnastkowym;
to GetCategories() metoda OlmStorage klasa – pobiera listę kategorii używanych w magazynie.

Poniższy przykład wyświetla wszystkie kategorie użyte w magazynie wraz z ich kolorami:

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

Pobierz kolor kategorii wiadomości

Możesz dopasować kategorie przypisane do konkretnej wiadomości do listy kategorii w magazynie, aby określić kolor każdej kategorii. Poniższy przykład odczytuje kategorie każdej wiadomości w folderze i wypisuje kolor każdej z nich:

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: Konwersja OLM na PST

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

OLM jest formatem bazy danych używanym przez Microsoft Outlook dla Mac. Pliki OLM przechowują wiadomości e‑mail, dane kalendarza, kontakty i ustawienia aplikacji, i nie są obsługiwane przez Outlook dla Windows. Aby przenieść skrzynkę pocztową z Outlooka dla Mac do Outlooka dla Windows, trzeba skonwertować plik OLM na format Outlooka PST format. Aspose.Email dla .NET umożliwia to w kodzie, bez konieczności instalacji Microsoft Outlook.

Jak działa konwersja

Aby przekonwertować plik OLM na PST, wykonaj następujące kroki:

Utwórz instancję OlmStorage klasa otwierająca źródłowy plik OLM.
Utwórz nowy plik PST przy użyciu PersonalStorage.Create metoda.
Zaimplementuj GetContainerClass metodę mapującą klasę wiadomości na odpowiadającą jej klasę folderu (kontenera), tak aby każdy folder został utworzony z właściwym typem w PST.
Zaimplementuj AddToPst metody, która rekurencyjnie odczytuje każdy folder i jego wiadomości z pliku OLM – przy użyciu EnumerateMapiMessages - i dodaje je do PST w tej samej kolejności, używając AddSubFolder i AddMessage metod klasy FolderInfo.

Przykład kodu

Poniższy kod pokazuje, jak przekonwertować plik OLM na PST.

Metoda Main:

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

Metodę GetContainerClass:

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

Metodę AddToPst:

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

Konwersja w odwrotnym kierunku (PST do OLM) nie jest obsługiwana, ponieważ plik OLM jest zawsze tworzony przez Outlook dla Mac po dodaniu konta i zsynchronizowaniu z serwerem poczty.