Lecture et conversion des fichiers Outlook

Travailler avec les fichiers OST

Aspose.Email pour .NET fournit une API pour lire les fichiers OST de Microsoft Outlook. Vous pouvez charger un fichier OST depuis le disque ou un flux dans une instance de la Aspose.Email.Outlook.Pst.PersonalStorage classe pour accéder à son contenu, tels que dossiers, sous‑dossiers et messages. Microsoft Outlook crée un fichier PST pour stocker les courriels lorsqu’il utilise les serveurs de messagerie POP3 ou IMAP. En revanche, il crée un fichier OST lorsque Microsoft Exchange est le serveur de messagerie. Les fichiers OST prennent également en charge des tailles de fichier supérieures à celles des fichiers PST.

Lire les fichiers OST

Le processus de lecture d’un fichier OST avec Aspose.Email est exactement le même que pour la lecture d’un fichier PST. Le même code peut lire à la fois les fichiers PST et OST : il suffit de fournir le nom de fichier correct au PersonalStorage.FromFile() méthode. Le fragment de code suivant montre comment lire les fichiers OST.

Convertir OST en PST

Essayez-le !

Convertissez les courriels et les archives de messages en ligne avec le gratuit Application de conversion Aspose.Email.

Aspose.Email permet de convertir un fichier OST en PST avec une seule ligne de code. De même, le fichier OST peut être créé à partir d’un fichier PST en utilisant la même ligne de code avec le FileFormat énumérateur. Actuellement, l’API prend en charge la conversion des formats OST vers PST sauf 2013/2016/2019/2021 et les versions futures. Le fragment de code suivant montre comment convertir OST en PST.

Pour effectuer d’autres opérations avec les fichiers OST, veuillez vous référer aux pages suivantes :

Convertir PST en OST

La conversion de PST en OST n’est pas prise en charge par Aspose.Email parce que l’OST est toujours créé par Outlook lors de l’ajout d’un compte et de la synchronisation avec le serveur de messagerie. La différence entre les fichiers PST et OST est que le PST n’est disponible que localement. Le contenu OST est également disponible sur le serveur de messagerie. Il n’est donc pas nécessaire de convertir PST en OST pour une utilisation locale. Cependant, vous pouvez importer un PST dans un compte existant à l’aide de l’assistant Import/Export d’Outlook.

OLM est un format de fichier spécifique utilisé par Microsoft Outlook pour stocker des données locales telles que les e‑mails, les pièces jointes, les notes, les données de calendrier, les contacts, les tâches, l’historique, et plus encore. Les fichiers OLM ne sont compatibles qu’avec Outlook pour Mac et ne peuvent pas être ouverts ou accessibles par Outlook pour Windows, qui utilise à la place le format de fichier PST.

Travailler avec les fichiers OLM

Ouvrir les fichiers OLM

Les fichiers au format OLM peuvent être ouverts de deux manières :

en utilisant le constructeur
en utilisant la méthode statique FromFile

Il existe des différences de comportement entre ces méthodes. Voir la section ci‑dessus.

Utilisation du constructeur

Pour ouvrir un fichier, appelez le constructeur de la OlmStorage classe et passez le nom complet du fichier ou le flux en argument :

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

Utilisation de la méthode statique FromFile

Pour ouvrir un fichier, utilisez la méthode statique FromFile et passez le nom complet du fichier ou le flux en argument :

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

Récupérer les dossiers

Pour accéder à la structure de répertoires d’un fichier OLM, créez une instance de OlmStorage classe en utilisant son constructeur et en passant le chemin du fichier. Une fois le fichier ouvert, accédez à sa structure de répertoires en utilisant le FolderHierarchy propriété. Cette propriété renvoie une liste de OlmFolder objets, chacun représentant un répertoire dans le fichier OLM. Pour explorer davantage la structure des répertoires, accédez au SubFolders propriété de chaque objet, qui renvoie une liste de ses sous‑répertoires. En utilisant ces propriétés, vous pouvez naviguer dans toute la hiérarchie de répertoires du fichier OLM et accéder à tous les répertoires et sous‑répertoires qu’il contient.

L’exemple ci‑dessous affiche la liste de tous les dossiers dans l’ordre hiérarchique :

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

Lors de l’utilisation du FromFile méthode pour ouvrir un fichier OLM, le FolderHierarchy la propriété ne sera pas initialisée par défaut et renverra null. Dans ce cas, appelez explicitement la méthode GetFolders pour initialiser la FolderHierarchy propriété et récupérer la liste des répertoires dans le fichier OLM :

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

De plus, il est possible d’obtenir n’importe quel dossier par son nom :

Appelez GetFolder méthode.
Passez le nom du dossier comme premier argument et la valeur indiquant s’il faut ignorer la sensibilité à la casse lors de la recherche d’un dossier, comme second paramètre.

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

Lister les e‑mails

OlmFolder classe, qui représente un dossier, possède les méthodes suivantes pour obtenir la liste des e‑mails :

EnumerateMessages implémente l’itération des e‑mails dans un dossier. Dans ce cas, chaque itération renvoie OlmMessageInfo objet, qui fournit des informations succinctes sur l’e‑mail.
EnumerateMapiMessages, implémente également l’itération des e‑mails dans un dossier, mais dans ce cas, chaque itération renvoie MapiMessage objet, qui représente l’email lui‑même, avec toutes ses propriétés.

Utilisation de la méthode EnumerateMessages

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

Utilisation de la méthode EnumerateMapiMessages

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

Autres propriétés utiles

Les autres propriétés utiles de la classe OlmFolder sont : HasMessages et MessageCount propriétés, qui renvoient la présence de messages dans le dossier et leur nombre.

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

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

Obtenir ou définir la date de modification d’un message

La date de modification représente la date et l’heure à laquelle le message OLM a été modifié pour la dernière fois. Vous pouvez utiliser le OlmMessageInfo.ModifiedDate propriété pour récupérer ou mettre à jour la valeur de la date de modification d’un message OLM.

Voici un exemple qui montre l’utilisation de la propriété :

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

Extraire les e‑mails et les éléments

OlmStorage classe possède ExtractMapiMessage méthode qui permet d’extraire des e‑mails. Cette méthode reçoit un OlmMessageInfo objet.

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

Utilisation de l’API de traversée

Vous pouvez extraire tous les éléments d’un fichier Outlook OLM autant que possible, sans déclencher d’exceptions, même si certaines données du fichier original sont corrompues. Pour ce faire, utilisez OlmStorage(TraversalExceptionsCallback callback) constructeur et Load(string fileName) méthode au lieu de la méthode FromFile. Le constructeur permet de définir une méthode de rappel.

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

La méthode de rappel rend disponibles les exceptions de chargement et de traversée.

Le Load la méthode renvoie ’true’ si le fichier a été chargé avec succès et que le parcours supplémentaire est possible. Si un fichier est corrompu et qu’aucun parcours n’est possible, elle renvoie ‘false’.

if (olm.Load(fileName))

Le snippet de code suivant et les étapes montrent comment utiliser cette API :

Créez une nouvelle instance de la OlmStorage classe, en passant un rappel de gestion des exceptions pour traiter les éventuelles exceptions survenues durant le processus.
Chargez le fichier OLM en appelant le Load méthode de l’instance OlmStorage.
Si le fichier OLM est chargé avec succès, obtenez la hiérarchie des dossiers en appelant le GetFolders méthode sur l’instance OlmStorage. Celle‑ci renvoie une liste d’objets OlmFolder.
Appelez la méthode ExtractItems en passant l’instance OlmStorage et la liste d’objets OlmFolder.
Dans la méthode ExtractItems, parcourez chaque dossier de la liste des dossiers.
Si le dossier contient des messages (e‑mails), affichez le nom du dossier dans la console avec Console.WriteLine(folder).
Parcourez les messages du dossier actuel en appelant la méthode EnumerateMessages sur l’instance OlmStorage, en passant le dossier actuel comme argument.
Affichez l’objet de chaque message dans la console avec Console.WriteLine(msg.Subject).
Si le dossier possède des sous‑dossiers, appelez à nouveau de manière récursive la méthode ExtractItems, en passant l’instance OlmStorage et les sous‑dossiers du dossier actuel.

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

Extraire des messages par identifiants

Parfois, il est nécessaire d’extraire des messages sélectionnés par identifiants. Par exemple, votre application stocke des identifiants dans une base de données et extrait un message à la demande. C’est le moyen efficace d’éviter de parcourir l’ensemble du stockage à chaque fois pour trouver un message spécifique à extraire. Cette fonctionnalité est disponible pour les stockages OLM. Le EntryId propriété du OlmMessageInfo classe obtient l’identifiant d’entrée du message. La surcharge ExtractMapiMessage(string id) méthode du OlmStorage classe récupère le message depuis OLM.

Le code ci‑dessous montre comment extraire des messages d’OLM par identifiants.

Le code exécute les étapes suivantes :

Initie une boucle foreach pour parcourir une liste de OlmMessageInfo objets. La boucle utilise le EnumerateMessages méthode de l’objet olmFolder pour récupérer une liste de tous les messages du dossier en cours d’itération.
La boucle extrait l’objet MapiMessage correspondant du stockage en appelant le ExtractMapiMessage(string id) méthode de OlmStorage classe, en passant le EntryId du message actuel en tant que paramètre.

L’objet MapiMessage récupéré peut être utilisé pour accéder au contenu du message et le manipuler. La boucle continue jusqu’à ce que tous les messages du dossier aient été traités.

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

Récupération du chemin du dossier

Vous pouvez également obtenir le chemin des dossiers dans le fichier OML. Aspose.Email fournit OlmFolder.Path propriété qui renvoie le chemin du dossier. L’extrait de code suivant démontre l’utilisation de OlmFolder.Path propriété permettant d’obtenir les chemins des dossiers dans le fichier OML.

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

Compter les éléments dans le dossier

Vous pouvez également compter le nombre d’éléments dans le dossier. Aspose.Email fournit OlmFolder.MessageCount propriété qui renvoie le nombre d’éléments dans le dossier. L’extrait de code suivant montre l’utilisation de OlmFolder.MessageCount propriété permettant d’obtenir le nombre d’éléments dans les dossiers du fichier OML.

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

Obtenir le nombre total d’éléments du OlmStorage

OlmStorage la classe possède également GetTotalItemsCount() méthode qui renvoie le nombre total d’éléments de message contenus dans le stockage OLM.

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

Récupération des couleurs de catégorie Outlook

Pour travailler avec les couleurs de catégorie ou les catégories d’éléments Outlook stockées dans les fichiers OLM, Aspose.Email propose les solutions suivantes :

OlmItemCategory classe – représente les catégories d’éléments Outlook disponibles par leur nom et leurs couleurs associées, représentées au format hexadécimal.
GetCategories() méthode du OlmStorage classe – récupère la liste des catégories.

L’exemple de code suivant montre comment obtenir toutes les catégories utilisées depuis le stockage OML :

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

L’exemple de code ci‑dessous montre comment obtenir la couleur d’une catégorie de message :

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

Convertir OLM en PST

OLM est un format de fichier de base de données utilisé par Microsoft Outlook pour les systèmes Mac. Les fichiers OLM stockent les messages électroniques, les données de calendrier, les contacts et les paramètres d’application. Un fichier OLM n’est pas pris en charge par Outlook pour Windows. Ainsi, il n’est pas possible d’ouvrir un fichier Outlook pour Mac (OLM) dans Outlook pour Windows. Si vous souhaitez migrer votre boîte aux lettres d’Outlook pour Mac vers Outlook pour Windows, il est nécessaire de convertir le fichier OLM d’Outlook pour Mac au format PST d’Outlook.

Étapes du code

Pour convertir un fichier OLM en PST, suivez les étapes ci‑dessous :

Créez une instance de OlmStorage classe pour ouvrir le OLM source.
Ouvrez un fichier OLM source.
Créez un nouveau fichier PST en utilisant Créer méthode.
Créez une méthode GetContainerClass pour associer la classe de message à une classe de dossier.
Créez une méthode AddToPst qui lit récursivement chaque dossier et ses messages depuis OLM à l’aide de la méthode EnumerateMapiMessages et les ajoute au PST dans le même ordre en utilisant les méthodes AddSubFolder et AddMessage.

Exemple de code

L’exemple de code suivant montre comment convertir OLM en PST.

Méthode Main :

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

Implémentation de la méthode 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";
}

Implémentation de la méthode 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);
    }
}

Travailler avec de gros fichiers PST