Lezen en converteren van Outlook‑bestanden

Werken met OST‑bestanden

Aspose.Email voor .NET biedt een API voor het lezen van Microsoft Outlook OST‑bestanden. U kunt een OST‑bestand van een schijf of een stream laden in een instantie van de Aspose.Email.Outlook.Pst.PersonalStorage klasse om toegang te krijgen tot de inhoud, zoals mappen, submappen en berichten. Microsoft Outlook maakt een PST‑bestand aan om e‑mail op te slaan bij gebruik van POP3‑ of IMAP‑mailservers. Daarentegen maakt het een OST‑bestand aan wanneer Microsoft Exchange de mailserver is. OST‑bestanden ondersteunen ook grotere bestandsgroottes dan PST‑bestanden.

OST‑bestanden lezen

Het proces voor het lezen van een OST‑bestand met Aspose.Email is precies hetzelfde als voor het lezen van een PST‑bestand. dezelfde code kan zowel PST‑ als OST‑bestanden lezen: geef gewoon de juiste bestandsnaam op aan de PersonalStorage.FromFile() methode. De volgende code‑snippet laat zien hoe je OST‑bestanden leest.

OST naar PST converteren

Probeer het uit!

E‑mails en berichtarchieven online converteren met de gratis Aspose.Email Conversie‑app.

Aspose.Email maakt het mogelijk om een OST‑bestand naar PST te converteren met één regel code. Evenzo kan een OST‑bestand worden gemaakt vanuit een PST‑bestand met dezelfde regel code met de FileFormat enumerator. Momenteel ondersteunt de API het converteren van OST‑formaten naar PST behalve 2013/2016/2019/2021 en toekomstige versies. Het onderstaande codefragment laat zien hoe u OST naar PST converteert.

Voor het uitvoeren van andere bewerkingen met OST‑bestanden, raadpleeg de volgende pagina’s:

PST naar OST converteren

Conversie van PST naar OST wordt niet ondersteund door Aspose.Email omdat OST altijd door Outlook wordt aangemaakt bij het toevoegen van een account en synchroniseren met de mailserver. Het verschil tussen PST‑ en OST‑bestanden is dat PST alleen lokaal beschikbaar is. OST‑inhoud is ook beschikbaar op de e‑mailserver. Er is daarom geen noodzaak om PST naar OST te converteren voor lokaal gebruik. Maar je kunt een PST importeren in een bestaand account via de Import/Export‑wizard in Outlook.

OLM is een specifiek bestandsformaat dat door Microsoft Outlook wordt gebruikt voor het opslaan van lokale gegevens zoals e‑mails, bijlagen, notities, agendagegevens, contacten, taken, geschiedenis en meer. OLM‑bestanden zijn alleen compatibel met Outlook voor Mac en kunnen niet worden geopend of benaderd door Outlook voor Windows, dat in plaats daarvan het PST‑formaat gebruikt.

Werken met OLM‑bestanden

Open OLM‑bestanden

OLM‑formaatbestanden kunnen op twee manieren worden geopend:

met constructor
met statische FromFile‑methode

Er zijn gedragsverschillen tussen deze methoden. Zie de sectie hieronder.

Gebruik constructor

Om een bestand te openen, roep de constructor van de OlmStorage klasse en geef de volledige bestandsnaam of stream als argument door:

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

Gebruik statische methode FromFile

Om een bestand te openen, gebruik statische methode FromFile en geef de volledige bestandsnaam of stream als argument door:

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

Mappen ophalen

Om de directory‑structuur van een OLM‑bestand te benaderen, maak een instantie van de OlmStorage klasse met behulp van de constructor en geef het pad naar het bestand door. Zodra het bestand is geopend, krijg je toegang tot de directory‑structuur met de FolderHierarchy eigenschap. Deze eigenschap retourneert een lijst van OlmFolder objecten, die elk een directory in het OLM‑bestand vertegenwoordigen. Om de directory‑structuur verder te verkennen, ga naar de SubFolders eigenschap van elk object, die een lijst van de subdirectory’s retourneert. Door deze eigenschappen te gebruiken, kun je door de volledige directory-hiërarchie van het OLM‑bestand navigeren en alle mappen en submappen benaderen die het bevat.

Het voorbeeld hieronder toont de lijst van alle mappen in hiërarchische volgorde:

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

Bij gebruik van de FromFile methode om een OLM‑bestand te openen, de FolderHierarchy eigenschap wordt standaard niet geïnitialiseerd en zal null teruggeven. Roep in dit geval expliciet de GetFolders‑methode aan om te initialiseren FolderHierarchy eigenschap en haal de lijst van directories op in het OLM-bestand:

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

Ook is het mogelijk om elke map op naam op te halen:

Roep GetFolder methode.
Geef de mapnaam als eerste argument en een waarde die aangeeft of hoofdlettergevoeligheid genegeerd moet worden bij het zoeken naar een map, als tweede parameter.

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

E-mails weergeven

OlmFolder klasse, die een map vertegenwoordigt, heeft de volgende methoden om de lijst met e‑mails op te halen:

EnumerateMessages implementeert iteratie van e-mails in een map. In dit geval retourneert elke iteratie OlmMessageInfo object, dat korte informatie over de e-mail biedt.
EnumerateMapiMessages, implementeert ook iteratie van e-mails in een map, maar in dit geval retourneert elke iteratie MapiMessage object, dat de e-mail zelf vertegenwoordigt, met alle eigenschappen.

Gebruik EnumerateMessages-methode

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

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

Andere handige eigenschappen

De andere bruikbare eigenschappen van de OlmFolder-klasse zijn: HasMessages en MessageCount eigenschappen, die de aanwezigheid van berichten in de map en hun aantal teruggeven.

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

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

De wijzigingsdatum van een bericht ophalen of instellen

De gewijzigde datum geeft de datum en tijd weer waarop het OLM‑bericht voor het laatst is gewijzigd. U kunt de OlmMessageInfo.ModifiedDate eigenschap om de gewijzigde datumwaarde van een OLM‑bericht op te halen of bij te werken.

Hier is een voorbeeld dat het gebruik van de eigenschap laat zien:

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

E‑mails en items extraheren

OlmStorage klasse heeft ExtractMapiMessage methode die het extraheren van e‑mails mogelijk maakt. Deze methode ontvangt een OlmMessageInfo object.

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

Gebruik van Traversal‑API

U kunt alle items uit een Outlook‑OLM‑bestand zo veel mogelijk extraheren, zonder uitzonderingen te werpen, zelfs als sommige gegevens van het oorspronkelijke bestand corrupt zijn. Gebruik hiervoor OlmStorage(TraversalExceptionsCallback callback) constructor en Load(string fileName) methode in plaats van de FromFile‑methode. De constructor maakt het mogelijk een callback‑methode op te geven.

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

De callback‑methode maakt de laad‑ en traversale‑uitzonderingen beschikbaar.

De Load methode retourneert ’true’ als het bestand succesvol is geladen en verdere doorloop mogelijk is. Als een bestand corrupt is en geen doorloop mogelijk is, wordt ‘false’ geretourneerd.

if (olm.Load(fileName))

De volgende codefragmenten en stappen laten zien hoe deze API te gebruiken:

Maak een nieuw exemplaar van de OlmStorage klasse aan te roepen, waarbij een callback voor foutafhandeling wordt meegegeven om eventuele uitzonderingen tijdens het proces af te handelen.
Laad het OLM‑bestand door de Load methode van de OlmStorage‑instantie.
Als het OLM‑bestand succesvol is geladen, verkrijg dan de maphiërarchie door de GetFolders methode op de OlmStorage‑instantie. Deze retourneert een lijst met OlmFolder‑objecten.
Roep de ExtractItems‑methode aan, waarbij de OlmStorage‑instantie en de lijst met OlmFolder‑objecten worden doorgegeven.
In de ExtractItems‑methode, itereren door elke map in de folders‑lijst.
Als de map berichten (e‑mails) bevat, print dan de mapnaam naar de console met Console.WriteLine(folder).
Itereer door de berichten in de huidige map door de EnumerateMessages‑methode aan te roepen op de OlmStorage‑instantie, waarbij de huidige map als argument wordt doorgegeven.
Print het onderwerp van elk bericht naar de console met Console.WriteLine(msg.Subject).
Als de map submappen heeft, roep dan recursief de ExtractItems‑methode opnieuw aan, waarbij de OlmStorage‑instantie en de submappen van de huidige map worden doorgegeven.

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

Berichten extraheren op identifiers

Soms is het nodig om geselecteerde berichten op basis van identifiers te extraheren. Bijvoorbeeld, uw applicatie slaat identifiers op in een database en haalt een bericht op verzoek op. Dit is de efficiënte manier om elke keer het volledige opslagmedium te doorlopen om een specifiek bericht te vinden om te extraheren. Deze functionaliteit is beschikbaar voor OLM‑opslag. De EntryId eigenschap van de OlmMessageInfo klasse krijgt de bericht‑entry‑identifier. De overladen ExtractMapiMessage(string id) methode van de OlmStorage klasse haalt het bericht op uit OLM.

De onderstaande code toont hoe berichten uit OLM geëxtraheerd kunnen worden op basis van identifiers.

De code voert de volgende stappen uit:

Initieert een foreach‑lus om door een lijst van OlmMessageInfo objecten. De lus gebruikt de EnumerateMessages methode van het olmFolder‑object aan te roepen om een lijst van alle berichten in de huidige map die wordt doorlopen op te halen.
De lus extraheert het overeenkomstige MapiMessage‑object uit de opslag door de ExtractMapiMessage(string id) methode van OlmStorage klasse, waarbij de EntryId van het huidige bericht als parameter.

Het opgehaalde MapiMessage‑object kan worden gebruikt om toegang te krijgen tot en de inhoud van het bericht te manipuleren. De lus gaat door totdat alle berichten in de map zijn verwerkt.

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

Mappad ophalen

Je kunt ook het mappad van mappen in het OLM‑bestand ophalen. Aspose.Email biedt OlmFolder.Path eigenschap die het mappad retourneert. De volgende codefragment toont het gebruik van OlmFolder.Path eigenschap om de mappaden in het OLM‑bestand op te halen.

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

Items tellen in map

Je kunt ook het aantal items in de map tellen. Aspose.Email biedt OlmFolder.MessageCount eigenschap die het aantal items in de map retourneert. De volgende codefragment toont het gebruik van OlmFolder.MessageCount eigenschap om het aantal items in de mappen van het OLM‑bestand op te halen.

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

Haal totale items‑aantal op van OlmStorage

OlmStorage klasse heeft ook GetTotalItemsCount() methode die het totale aantal berichtitems in de OLM‑opslag retourneert.

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

Ophalen van Outlook‑categoriënkleuren

Om met categoriekleuren of Outlook‑itemcategorieën die zijn opgeslagen in OLM‑bestanden te werken, biedt Aspose.Email de volgende oplossingen:

OlmItemCategory klasse - vertegenwoordigt Outlook‑itemcategorieën die beschikbaar zijn via hun naam en gekoppelde kleuren, weergegeven in hexadecimale notatie.
GetCategories() methode van de OlmStorage klasse - haalt categorielijst op.

Het volgende codevoorbeeld toont hoe u alle gebruikte categorieën uit OML‑opslag kunt ophalen:

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

Het onderstaande codevoorbeeld laat zien hoe u de kleur van een berichtcategorie krijgt:

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 naar PST converteren

OLM Het is een databasebestandformaat dat wordt gebruikt door Microsoft Outlook voor Mac-systemen. OLM‑bestanden slaan e‑mailberichten, agenda‑gegevens, contactgegevens en toepassingsinstellingen op. Een OLM‑bestand wordt niet ondersteund door Outlook voor Windows. Daarom is het niet mogelijk om een Outlook‑voor‑Mac (OLM)‑bestand te openen in Outlook voor Windows. Als u uw postvak wilt migreren van Outlook voor Mac naar Outlook voor Windows, moet u het OLM‑bestand van Outlook voor Mac converteren naar het Outlook‑PST‑bestandformaat.

Code‑stappen

Volg de onderstaande stappen om een OLM‑bestand naar PST te converteren:

Maak een instantie van OlmStorage klasse om bron‑OLM te openen.
Open een bron‑OLM‑bestand.
Maak een nieuw PST‑bestand aan met Maak methode.
Maak een GetContainerClass‑methode om de berichtklasse te koppelen aan een mapklasse.
Maak een AddToPst‑methode die recursief elke map en de bijbehorende berichten uit OLM leest met behulp van de EnumerateMapiMessages‑methode en deze in dezelfde volgorde toevoegt aan de PST met de AddSubFolder‑ en AddMessage‑methoden.

Codevoorbeeld

Het volgende codevoorbeeld laat zien hoe OLM naar PST wordt geconverteerd.

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

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

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

Werken met grote PST‑bestanden