Documentation – Arbeta med OLM-filer

Net: Öppna OLM-filer

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

Aspose.Email för .NET representerar en Outlook för Mac‑lagringsfil med OlmStorage klass. Denna artikel visar hur man öppnar en OLM‑fil från en sökväg eller en ström, och hur man säkert laddar en fil som kan vara korrupt.

Öppna en OLM‑fil

En OLM‑fil kan öppnas på två sätt:

använda en konstruktor;
använda den statiska FromFile metod.

Det finns en skillnad i beteende mellan dessa två tillvägagångssätt som påverkar hur mapphierarkin initieras. Se Navigera i OLM-mappar för detaljer.

Använda konstruktorn

För att öppna en fil, anropa konstruktorn för OlmStorage klass och skicka hela filnamnet som argument. Eftersom OlmStorage implementerar IDisposable, omslut den i en using sats så att den underliggande filhandtaget släpps när du är klar.

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

Använda den statiska FromFile‑metoden

För att öppna en fil, använd den statiska FromFile metod och skicka hela filnamnet som argument:

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

Öppna en OLM‑fil från en ström

När OLM‑data inte kommer från en lokal sökväg – till exempel, den hämtas från en databas, en nätverksresurs eller molnlagring – kan du öppna den direkt från en Stream. Använd OlmStorage(Stream) konstruktorn eller den statiska FromStream metod.

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

Den statiska metoden fungerar på samma sätt:

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

Behåll källströmmen öppen så länge du åtkomstlagrar. Att disponera strömmen innan du är färdig med att läsa mappar och meddelanden orsakar läsfel.

Öppna en korrupt OLM‑fil

Om en fil kan vara delvis korrupt kan du fortfarande extrahera så mycket data som möjligt utan att stoppa vid första felet. Gör så här, skapa OlmStorage instans med OlmStorage(TraversalExceptionsCallback callback) konstruktorn, ladda sedan filen med Load metoden istället för FromFile.

Återuppringningen mottar de undantag som uppstår under laddning och traversal, så att du kan logga eller ignorera dem. Load metod returnerar true om filen har lästs in korrekt och traversering är möjlig, och false om filen är för korrupt för att traverseras.

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 ett komplett exempel på att extrahera objekt från en korrupt fil, se Läsa och extrahera OLM-meddelanden.

Net: Navigera i OLM-mappar

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

En OLM‑fil organiserar sin data i ett träd av mappar, var och en representerad av ett OlmFolder objekt. Denna artikel visar hur du enumererar mapphierarkin, hämtar en specifik mapp efter namn, navigerar undermappar och läser mapp‑sökvägar.

Hämta mapphierarkin

När en fil är öppen, nå dess katalogstruktur genom FolderHierarchy egenskap. Denna egenskap returnerar en lista över OlmFolder objekt, var och en representerar en top‑nivå‑katalog i OLM‑filen. För att gå djupare, läs SubFolders egenskap för varje mapp, som returnerar dess undermappar. Med dessa två medlemmar kan du gå igenom hela hierarkin.

Exemplet nedan skriver ut alla mappar i hierarkisk ordning:

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 och FromFile‑metoden

Sättet du öppnar filen på påverkar hur FolderHierarchy betecknas:

När du öppnar filen med konstruktorn, FolderHierarchy egenskapen initieras automatiskt.
När du öppnar filen med FromFile metod, FolderHierarchy är inte initierad som standard och returnerar null. I detta fall, anropa GetFolders metod explicit för att initiera hierarkin och hämta listan över kataloger:

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

Hämta en mapp efter namn

För att hämta en enskild mapp efter namn, anropa GetFolder metod. Skicka mappnamnet som första argument och en boolesk som andra argument som indikerar om skiftläge ska ignoreras under sökningen.

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

Hämta en undermapp efter namn

Varje OlmFolder låter dig också lokalisera en barnmapp direkt med GetSubFolder metod. Skicka undermappens namn och om skiftläge ska ignoreras. Detta är användbart när du redan har en föräldramapp och vill gå djupare utan att skanna hela hierarkin igen.

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

Hämta mapp-sökvägar

Du kan läsa den fullständiga sökvägen för vilken mapp som helst via OlmFolder.Path egenskap. Följande snutt skriver ut sökvägen för varje mapp i filen:

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: Läsa och extrahera OLM-meddelanden

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

Efter att du har öppnat en OLM-fil och lokalisera en mapp kan du lista dess meddelanden, läsa kort meddelandeinformation, filtrera och paginera genom stora mappar samt extrahera enskilda meddelanden som MapiMessage objekt. Denna artikel täcker alla dessa operationer.

Lista meddelanden i en mapp

Den OlmFolder klass tillhandahåller två sätt att iterera över meddelandena den innehåller:

EnumerateMessages returnerar ett OlmMessageInfo objekt vid varje iteration. Detta objekt innehåller kort information om meddelandet och är det mest effektiva sättet att skanna en mapp.
EnumerateMapiMessages returnerar en fullständig MapiMessage objekt vid varje iteration, med alla meddelandets egenskaper inlästa.

Använda EnumerateMessages

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

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

Läs meddelandeinformation

Varje OlmMessageInfo objektet exponerar en uppsättning skrivskyddade egenskaper som beskriver ett meddelande utan att ladda dess fullständiga innehåll. Detta är det mest effektiva sättet att bygga en listvy eller att besluta vilka meddelanden som ska extraheras.

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

Hämta det modifierade datumet för ett meddelande

Det modifierade datumet representerar datum och tid då OLM‑meddelandet senast ändrades. Använd OlmMessageInfo.ModifiedDate egenskap för att läsa den:

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

Filtrera meddelanden med en fråga

För stora mappar kan du hämta bara de meddelanden som matchar en uppsättning kriterier istället för att iterera över allt. Skicka en MailQuery till EnumerateMessages(MailQuery query) overload. Bygg frågan med en MailQueryBuilder.

Exemplet nedan enumererar bara de meddelanden som mottagits under de senaste sju dagarna vars ämne innehåller ordet "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);
    }
}

Bläddra genom meddelanden

När en mapp innehåller ett stort antal meddelanden kan du läsa dem i partier med EnumerateMessages(int skip, int count) overload. skip parametern är antalet meddelanden att hoppa över, och count är antalet meddelanden som ska returneras.

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

Extrahera ett meddelande som MapiMessage

Den OlmStorage klass tillhandahåller ExtractMapiMessage metod, som extraherar ett fullständigt MapiMessage från en OlmMessageInfo objekt. Detta är användbart när du först skannar en mapp med EnumerateMessages och sedan extrahera bara de meddelanden du faktiskt behöver.

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

Extrahera meddelanden efter identifierare

Ibland behöver du extrahera utvalda meddelanden efter deras identifierare. Till exempel kan en applikation lagra identifierare i en databas och extrahera ett meddelande på begäran istället för att traversera hela lagret varje gång. EntryId egenskap av OlmMessageInfo tillhandahåller meddelandets postidentifikator, och den överlagrade ExtractMapiMessage(string id) metod hämtar meddelandet med den identifieraren.

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

Extrahera objekt med Traversal‑API‑t

Du kan extrahera varje objekt från en OLM‑fil – så långt som möjligt – utan att kasta undantag, även när någon data i den ursprungliga filen är korrupt. För att göra detta, skapa OlmStorage instans med OlmStorage(TraversalExceptionsCallback callback) konstruktör och läser in filen med Load metod. Callbacken exponerar laddnings‑ och traverserings‑undantag.

Den Load metod returnerar true om filen har lästs in korrekt och traversering är möjlig, och false om filen är korrupt och ingen traversering är möjlig. Observera att när du traverserar objekt mapp för mapp, anropar du lagrets EnumerateMessages(OlmFolder folder) metod, med mappen som argument.

Stegen är:

Skapa en ny OlmStorage instans, med en callback för undantagshantering.
Läs in OLM‑filen genom att anropa Load metod.
Om filen läses in korrekt, hämta mapphierarkin genom att anropa GetFolders.
Rekursivt iterera över varje mapp. För mappar som har meddelanden, enumerera dem med lagrets EnumerateMessages metod och bearbeta varje.
Rekursion in i eventuella undermappar.

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: Räkna objekt och arbeta med kategorier

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

Utöver att läsa enskilda meddelanden låter Aspose.Email för .NET dig inspektera hur många objekt en OLM‑fil eller en mapp innehåller samt läsa Outlook‑kategorierna – inklusive deras färger – som lagras i filen. Denna artikel täcker båda.

Kontrollera om en mapp har meddelanden

Den OlmFolder.HasMessages egenskap indikerar om en mapp innehåller några meddelanden, och den OlmFolder.MessageCount egenskap returnerar hur många.

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

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

Räkna objekt i varje mapp

Använd OlmFolder.MessageCount egenskap för att rapportera antalet objekt i varje mapp i filen:

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

Hämta totalt antal objekt i lagret

Den OlmStorage klassen har en GetTotalItemsCount() metod som returnerar det totala antalet meddelandeobjekt som finns i hela OLM‑lagret:

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

Hämta Outlook‑kategorifärger

För att arbeta med Outlook‑objektkategorier som lagras i en OLM‑fil erbjuder Aspose.Email:

de OlmItemCategory klass – representerar en Outlook‑objektkategori, tillgänglig via dess Namn och associerad Färg, representerad i hexadecimal format;
de GetCategories() metod för OlmStorage klass – hämtar listan över kategorier som används i lagret.

Följande exempel listar varje kategori som används i lagret tillsammans med dess färg:

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

Hämta kategorifärgen för ett meddelande

Du kan matcha de kategorier som tilldelats ett särskilt meddelande mot lagrets kategorilista för att avgöra varje kategoris färg. Exemplet nedan läser kategorierna för varje meddelande i en mapp och skriver ut färgen på varje:

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: Konvertera OLM till PST

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

OLM är ett databasfilformat som används av Microsoft Outlook för Mac. OLM‑filer lagrar e‑postmeddelanden, kalenderdata, kontakter och programinställningar, och de stöds inte av Outlook för Windows. För att migrera en brevlåda från Outlook för Mac till Outlook för Windows måste du konvertera OLM‑filen till Outlook‑ PST format. Aspose.Email för .NET låter dig göra detta i kod, utan att Microsoft Outlook är installerat.

Hur konverteringen fungerar

För att konvertera en OLM‑fil till PST, följ dessa steg:

Skapa en instans av OlmStorage klass för att öppna käll‑OLM‑filen.
Skapa en ny PST-fil med PersonalStorage.Create metod.
Implementera en GetContainerClass metod som mappar en meddelandeklass till motsvarande mapp‑(container)‑klass, så varje mapp skapas med korrekt typ i PST.
Implementera en AddToPst metod som rekursivt läser varje mapp och dess meddelanden från OLM‑filen – med hjälp av EnumerateMapiMessages - och lägger till dem i PST i samma ordning, med hjälp av AddSubFolder och AddMessage metoder för FolderInfo.

Kodexempel

Följande kod visar hur man konverterar en OLM‑fil till PST.

Main metod:

// 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‑metod:

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‑metod:

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

Omvänd konvertering (PST till OLM) stöds inte, eftersom en OLM‑fil alltid skapas av Outlook för Mac när ett konto läggs till och synkroniseras med mailservern.