Läsa och konvertera Outlook‑filer

Arbeta med OST‑filer

Aspose.Email för .NET tillhandahåller ett API för att läsa Microsoft Outlook OST‑filer. Du kan ladda en OST‑fil från en disk eller en ström till en instans av Aspose.Email.Outlook.Pst.PersonalStorage klass för att komma åt dess innehåll, såsom mappar, undermappar och meddelanden. Microsoft Outlook skapar en PST‑fil för att lagra e‑post när man använder POP3‑ eller IMAP‑mailservrar. I kontrast skapar den en OST‑fil när Microsoft Exchange är mailserver. OST‑filer stöder även större filstorlekar än PST‑filer.

Läsa OST‑filer

Processen för att läsa en OST-fil med Aspose.Email är exakt densamma som för att läsa en PST-fil. Samma kod kan läsa både PST- och OST-filer: ange bara rätt filnamn till PersonalStorage.FromFile() metod. Följande kodexempel visar hur du läser OST-filer.

Konvertera OST till PST

Try it out!

Konvertera e‑post och meddelandearkiv online med den kostnadsfria Aspose.Email konverteringsapp.

Aspose.Email gör det möjligt att konvertera en OST-fil till PST med en enda kodrad. På samma sätt kan en OST-fil skapas från en PST-fil med samma kodrad med FileFormat enumerator. För närvarande stödjer API:t konvertering av OST‑format till PST förutom 2013/2016/2019/2021 och framtida versioner. Följande kodsnutt visar hur man konverterar OST till PST.

För att utföra andra operationer med OST-filer, se följande sidor:

Konvertera PST till OST

Konvertering från PST till OST stöds inte av Aspose.Email eftersom OST alltid skapas av Outlook när ett konto läggs till och synkroniseras med mailservern. Skillnaden mellan PST- och OST-filer är att PST bara är tillgänglig lokalt. OST-innehåll är också tillgängligt på e‑postservern. Så det finns ingen anledning att konvertera PST till OST för lokalt bruk. Men du kan importera PST till ett befintligt konto med Import/Export‑guiden i Outlook.

OLM är ett specifikt filformat som används av Microsoft Outlook för att lagra lokala data såsom e‑post, bilagor, anteckningar, kalenderdata, kontakter, uppgifter, historik och mer. OLM-filer är endast kompatibla med Outlook för Mac och kan inte öppnas eller nås av Outlook för Windows, som istället använder PST-filformatet.

Arbeta med OLM-filer

Öppna OLM-filer

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

använder konstruktorn
använder den statiska FromFile‑metoden

Det finns skillnader i beteende mellan dessa metoder. Se avsnittet nedan.

Använda konstruktor

För att öppna en fil, anropa konstruktorn för OlmStorage klass och skicka hela filnamnet eller stream som argument till den:

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

Använda den statiska metoden FromFile

För att öppna en fil, använd den statiska metoden FromFile och skicka hela filnamnet eller en ström som argument till den:

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

Hämta mappar

För att komma åt katalogstrukturen i en OLM-fil, skapa en instans av OlmStorage klassen med dess konstruktor och ange sökvägen till filen. När filen är öppen, åtkom dess katalogstruktur med FolderHierarchy egenskap. Denna egenskap returnerar en lista över OlmFolder objekt, där varje representerar en katalog i OLM-filen. För att utforska katalogstrukturen vidare, åtkom SubFolders egenskap hos varje objekt, som returnerar en lista över dess underkataloger. Genom att använda dessa egenskaper kan du navigera genom hela kataloghierarkin i OLM-filen och komma åt alla kataloger och underkataloger som den innehåller.

Exemplet nedan visar listan över alla mappar i hierarkisk ordning:

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

När du använder FromFile metod för att öppna en OLM‑fil, den FolderHierarchy egenskapen initieras inte som standard och returnerar null. Anropa i detta fall GetFolders-metoden explicit för att initiera FolderHierarchy egenskap och hämta listan över kataloger i OLM-filen:

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

Det är också möjligt att hämta en valfri mapp med namn:

Anropa GetFolder metod.
Skicka mappnamnet som det första argumentet och värdet som visar om skiftlägeskänslighet ska ignoreras vid sökning efter en mapp som det andra parametern.

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

Lista e‑post

OlmFolder klass, som representerar en mapp, har följande metoder för att hämta listan med e‑postmeddelanden:

EnumerateMessages implementerar iteration av e‑post i en mapp. I detta fall returnerar varje iteration OlmMessageInfo objekt, som ger kort information om e‑post.
EnumerateMapiMessages, implementerar också iteration av e‑post i en mapp, men i detta fall returnerar varje iteration MapiMessage objekt, som representerar själva e‑postmeddelandet med alla egenskaper.

Använda EnumerateMessages-metoden

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-metoden

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

Andra användbara egenskaper

De andra användbara egenskaperna i OlmFolder-klassen är: HasMessages och MessageCount egenskaper, som returnerar närvaron av meddelanden i mappen och deras antal.

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

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

Hämta eller sätt det modifierade datumet för ett meddelande

Det modifierade datumet representerar datum och tid då OLM‑meddelandet senast ändrades. Du kan använda OlmMessageInfo.ModifiedDate egenskap för att hämta eller uppdatera det modifierade datumvärdet för ett OLM‑meddelande.

Här är ett exempel som demonstrerar användningen av egenskapen:

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

Extrahera e‑post och objekt

OlmStorage klassen har ExtractMapiMessage metod som möjliggör att extrahera e‑post. Denna metod tar emot en 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);
        }
    }
}

Användning av Traversal‑API

Du kan extrahera alla objekt från en Outlook‑OLM‑fil så långt det går, utan att kasta undantag, även om vissa data i originalfilen är skadade. För att göra detta, använd OlmStorage(TraversalExceptionsCallback callback) konstruktor och Load(string fileName) metod istället för FromFile‑metoden. Konstruktorn tillåter att definiera en återanropsmetod.

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

Återanropsmetoden gör laddnings- och traverseringsundantag tillgängliga.

Den Load metoden returnerar ’true’ om filen har laddats framgångsrikt och vidare traversering är möjlig. Om en fil är korrupt och ingen traversering är möjlig, returneras ‘false’.

if (olm.Load(fileName))

Följande kodsnutt och stegen visar hur man använder detta API:

Skapa en ny instans av OlmStorage klass, och skicka med en återanropningsfunktion för undantagshantering för att hantera eventuella undantag som uppstår under processen.
Läs in OLM‑filen genom att anropa Load metod på OlmStorage‑instansen.
Om OLM‑filen har laddats framgångsrikt, hämta mapphierarkin genom att anropa GetFolders metod på OlmStorage‑instansen. Den returnerar en lista med OlmFolder‑objekt.
Anropa ExtractItems‑metoden och skicka med OlmStorage‑instansen samt listan med OlmFolder‑objekt.
I ExtractItems‑metoden, iterera igenom varje mapp i listan över mappar.
Om mappen innehåller meddelanden (e‑post) skriv ut mappnamnet till konsolen med Console.WriteLine(folder).
Iterera genom meddelandena i den aktuella mappen genom att anropa EnumerateMessages‑metoden på OlmStorage‑instansen och skicka med den aktuella mappen som argument.
Skriv ut ämnet för varje meddelande till konsolen med Console.WriteLine(msg.Subject).
Om mappen har undermappar, anropa rekursivt ExtractItems‑metoden igen och skicka med OlmStorage‑instansen samt undermapparna för den aktuella mappen.

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

Extrahera meddelanden med identifierare

Ibland krävs det att extrahera utvalda meddelanden med identifierare. Till exempel lagrar din applikation identifierare i en databas och extraherar ett meddelande på begäran. Detta är ett effektivt sätt att undvika att gå igenom hela lagringen varje gång för att hitta ett specifikt meddelande att extrahera. Denna funktion är tillgänglig för OLM‑lagringar. Den EntryId egenskap hos OlmMessageInfo klass hämtar meddelandets entry‑identifierare. Den överlagrade ExtractMapiMessage(string id) metod för OlmStorage klass hämtar meddelandet från OLM.

Koden nedan visar hur man extraherar meddelanden från OLM med identifierare.

Koden utför följande steg:

Initierar en foreach‑loop för att iterera genom en lista av OlmMessageInfo objekt. Loopen använder EnumerateMessages metoden på olmFolder‑objektet för att hämta en lista över alla meddelanden i den aktuella mappar som itereras.
Loopen extraherar motsvarande MapiMessage‑objekt från lagringen genom att anropa ExtractMapiMessage(string id) metod för OlmStorage klass, som skickar in EntryId för det aktuella meddelandet som en parameter.

Det hämtade MapiMessage‑objektet kan användas för att komma åt och manipulera meddelandets innehåll. Loopen fortsätter tills alla meddelanden i mappen har behandlats.

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

Hämta mappväg

Du kan också hämta mappvägen för mappar i OML‑filen. Aspose.Email tillhandahåller OlmFolder.Path egenskap som returnerar mappvägen. Följande kodavsnitt demonstrerar användningen av OlmFolder.Path egenskap för att få mappvägarna i OML‑filen.

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

Räkna objekt i mapp

Du kan också räkna antalet objekt i mappen. Aspose.Email tillhandahåller OlmFolder.MessageCount egenskap som returnerar antalet objekt i mappen. Följande kodavsnitt demonstrerar användningen av OlmFolder.MessageCount egenskap för att få antalet objekt i mapparna i OML‑filen.

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

Hämta totalt antal objekt i OlmStorage

OlmStorage klassen har också GetTotalItemsCount() metod som returnerar det totala antalet meddelandeobjekt som finns i OLM‑lagringen.

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

Hämtning av Outlook‑kategorifärger

För att arbeta med kategori‑färger eller Outlook‑objektkategorier lagrade i OLM‑filer erbjuder Aspose.Email följande lösningar:

OlmItemCategory klass – representerar Outlook‑objektkategorier som finns tillgängliga via namn och tillhörande färger, representerade i hexadecimalt format.
GetCategories() metod för OlmStorage klass – hämtar kategorilista.

Följande kodexempel demonstrerar hur man får alla använda kategorier från OML‑lagring:

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

Kodexemplet nedan visar hur man får färgen för en meddelandekategori:

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

Konvertera OLM till PST

OLM är ett databasfilformat som används av Microsoft Outlook för Mac‑system. OLM‑filer lagrar e‑postmeddelanden, kalenderdata, kontaktdata och programinställningar. En OLM‑fil stöds inte av Outlook för Windows. Därför är det inte möjligt att öppna en Outlook för Mac (OLM)‑fil i Outlook för Windows. Om du vill migrera din brevlåda från Outlook för Mac till Outlook för Windows är det nödvändigt att konvertera OLM‑filen till Outlook PST‑filformat.

Kodsteg

För att konvertera en OLM‑fil till PST, följ stegen nedan:

Skapa en instans av OlmStorage klass för att öppna käll‑OLM.
Öppna en OLM‑källfil.
Skapa en ny PST‑fil med hjälp av Skapa metod.
Skapa en GetContainerClass‑metod för att kartlägga meddelandeklassen till en mappklass.
Skapa en AddToPst‑metod som rekursivt läser varje mapp och dess meddelanden från OLM med EnumerateMapiMessages‑metoden och lägger till dem i PST i samma ordning med metoderna AddSubFolder och AddMessage.

Kodexempel

Följande kodexempel visar hur man konverterar OLM till PST.

Main metod:

// 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 metodimplementation:

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 metodimplementation:

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

Arbeta med stora PST-filer