Lettura e conversione dei file Outlook

Lavorare con file OST

Aspose.Email per .NET fornisce un’API per leggere i file OST di Microsoft Outlook. Puoi caricare un file OST da disco o da uno stream in un’istanza di Aspose.Email.Outlook.Pst.PersonalStorage classe per accedere ai suoi contenuti, come cartelle, sottocartelle e messaggi. Microsoft Outlook crea un file PST per archiviare le e‑mail quando si utilizzano server di posta POP3 o IMAP. Al contrario, crea un file OST quando Microsoft Exchange è il server di posta. I file OST supportano anche dimensioni più grandi rispetto ai file PST.

Leggi file OST

Il processo per leggere un file OST con Aspose.Email è esattamente lo stesso di quello per leggere un file PST. Lo stesso codice può leggere sia file PST sia OST: basta fornire il nome del file corretto al PersonalStorage.FromFile() metodo. Il seguente frammento di codice mostra come leggere i file OST.

Converti OST in PST

Provalo!

Converti email e archivi di messaggi online con il gratuito Applicazione di Conversione Aspose.Email.

Aspose.Email rende possibile convertire un file OST in PST con una sola riga di codice. Allo stesso modo, il file OST può essere creato da un file PST usando la stessa riga di codice con il FileFormat enumeratore. Attualmente, l’API supporta la conversione dei formati OST in PST eccetto le versioni 2013/2016/2019/2021 e future. Il frammento di codice seguente mostra come convertire OST in PST.

Per eseguire altre operazioni con i file OST, consulta le pagine seguenti:

Converti PST in OST

La conversione da PST a OST non è supportata da Aspose.Email perché l’OST è sempre creato da Outlook quando si aggiunge un account e si sincronizza con il server di posta. La differenza tra i file PST e OST è che il PST è disponibile solo localmente. Il contenuto OST è disponibile anche sul server di posta elettronica. Pertanto non è necessario convertire PST in OST per uso locale. Tuttavia è possibile importare un PST in un account esistente utilizzando la procedura guidata Importa/Esporta di Outlook.

OLM è un formato di file specifico utilizzato da Microsoft Outlook per memorizzare dati locali come email, allegati, note, dati del calendario, contatti, attività, cronologia e altro. I file OLM sono compatibili solo con Outlook per Mac e non possono essere aperti o acceduti da Outlook per Windows, che utilizza invece il formato di file PST.

Lavorare con i File OLM

Apri File OLM

I file in formato OLM possono essere aperti in due modi:

usando il costruttore
usando il metodo statico FromFile

Esistono differenze di comportamento tra questi metodi. Vedi la sezione seguente.

Utilizzo del Costruttore

Per aprire un file, chiama il costruttore della OlmStorage classe e passa il nome file completo o lo stream come argomento:

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

Utilizzo del metodo statico FromFile

Per aprire un file, usa il metodo statico FromFile e passa il nome completo del file o lo stream come argomento:

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

Recupera Cartelle

Per accedere alla struttura di directory di un file OLM, crea un’istanza della OlmStorage classe usando il suo costruttore e passando il percorso al file. Una volta aperto il file, accedi alla sua struttura di directory utilizzando il FolderHierarchy proprietà. Questa proprietà restituisce un elenco di OlmFolder oggetti, ciascuno rappresentante una directory nel file OLM. Per esplorare ulteriormente la struttura delle directory, accedi al SubFolders proprietà di ogni oggetto, che restituisce un elenco delle sue sottodirectory. Utilizzando queste proprietà, è possibile navigare nell’intera gerarchia di directory del file OLM e accedere a tutte le directory e sottodirectory che contiene.

L’esempio seguente mostra l’elenco di tutte le cartelle in ordine gerarchico:

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

Quando si utilizza il FromFile metodo per aprire un file OLM, il FolderHierarchy la proprietà non verrà inizializzata di default e restituirà null. In questo caso, chiama esplicitamente il metodo GetFolders per inizializzarla FolderHierarchy proprietà e recuperare l’elenco delle directory nel file OLM:

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

Inoltre, è possibile ottenere qualsiasi cartella per nome:

Chiama GetFolder metodo.
Passa il nome della cartella come primo argomento e il valore, che indica se ignorare la distinzione tra maiuscole e minuscole nella ricerca di una cartella, come secondo parametro.

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

Elenca Email

OlmFolder classe, che rappresenta una cartella, ha i seguenti metodi per ottenere l’elenco delle email:

EnumerateMessages implementa l’iterazione delle email in una cartella. In questo caso, ogni iterazione restituisce OlmMessageInfo oggetto, che fornisce informazioni brevi sull’email.
EnumerateMapiMessages, implementa anche l’iterazione delle email in una cartella, ma in questo caso, ogni iterazione restituisce MapiMessage oggetto, che rappresenta l’email stessa, con tutte le proprietà.

Utilizzo del metodo EnumerateMessages

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

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

Altre proprietà utili

Le altre proprietà utili della classe OlmFolder sono: HasMessages e MessageCount proprietà, che restituiscono la presenza dei messaggi nella cartella e il loro conteggio.

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

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

Ottieni o imposta la data di modifica di un messaggio

La data di modifica rappresenta la data e l’ora in cui il messaggio OLM è stato modificato l’ultima volta. Puoi usare il OlmMessageInfo.ModifiedDate proprietà per recuperare o aggiornare il valore della data di modifica di un messaggio OLM.

Ecco un esempio che dimostra l’uso della proprietà:

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

Estrai e‑mail e elementi

OlmStorage classe ha ExtractMapiMessage metodo che consente di estrarre e‑mail. Questo metodo riceve un OlmMessageInfo oggetto.

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

Utilizzo dell’API di attraversamento

Puoi estrarre tutti gli elementi da un file Outlook OLM il più possibile, senza lanciare eccezioni, anche se alcuni dati del file originale sono danneggiati. Per fare ciò, utilizza OlmStorage(TraversalExceptionsCallback callback) costruttore e Load(string fileName) metodo al posto del metodo FromFile. Il costruttore consente di definire un metodo callback.

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

Il metodo callback rende disponibili le eccezioni di caricamento e di attraversamento.

Il Load il metodo restituisce ’true’ se il file è stato caricato con successo e è possibile continuare l’attraversamento. Se un file è corrotto e l’attraversamento non è possibile, restituisce ‘false’.

if (olm.Load(fileName))

Il frammento di codice seguente e i passaggi mostrano come utilizzare questa API:

Crea una nuova istanza della OlmStorage classe, passando una callback di gestione delle eccezioni per gestire eventuali eccezioni riscontrate durante il processo.
Carica il file OLM chiamando il Load metodo dell’istanza OlmStorage.
Se il file OLM viene caricato correttamente, ottieni la gerarchia delle cartelle chiamando il GetFolders metodo sull’istanza OlmStorage. Questo restituisce un elenco di oggetti OlmFolder.
Chiama il metodo ExtractItems, passando l’istanza OlmStorage e l’elenco di oggetti OlmFolder.
Nel metodo ExtractItems, itera attraverso ogni cartella nella lista delle cartelle.
Se la cartella contiene messaggi (email), stampa il nome della cartella nella console usando Console.WriteLine(folder).
Itera attraverso i messaggi nella cartella corrente chiamando il metodo EnumerateMessages sull’istanza OlmStorage, passando la cartella corrente come argomento.
Stampa l’oggetto di ogni messaggio nella console usando Console.WriteLine(msg.Subject).
Se la cartella contiene sottocartelle, chiama ricorsivamente di nuovo il metodo ExtractItems, passando l’istanza OlmStorage e le sottocartelle della cartella corrente.

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

Estrai messaggi per identificatori

A volte è necessario estrarre messaggi selezionati per identificatore. Per esempio, la tua applicazione memorizza gli identificatori in un database ed estrae un messaggio su richiesta. Questo è il modo efficiente per evitare di attraversare l’intero archivio ogni volta per trovare un messaggio specifico da estrarre. Questa funzionalità è disponibile per gli archivi OLM. Il EntryId proprietà del OlmMessageInfo classe che ottiene l’identificatore di voce del messaggio. Il sovraccarico ExtractMapiMessage(string id) metodo del OlmStorage classe che recupera il messaggio da OLM.

Il codice qui sotto mostra come estrarre messaggi da OLM per identificatori.

Il codice esegue i seguenti passaggi:

Avvia un ciclo foreach per iterare attraverso un elenco di OlmMessageInfo oggetti. Il ciclo utilizza il EnumerateMessages metodo dell’oggetto olmFolder per recuperare un elenco di tutti i messaggi nella cartella corrente in iterazione.
Il ciclo estrae l’oggetto MapiMessage corrispondente dallo storage chiamando il ExtractMapiMessage(string id) metodo di OlmStorage classe, passando il EntryId del messaggio corrente come parametro.

L’oggetto MapiMessage recuperato può essere usato per accedere e manipolare il contenuto del messaggio. Il ciclo continua finché tutti i messaggi nella cartella non sono stati elaborati.

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

Recupero del percorso della cartella

Puoi anche ottenere il percorso della cartella dei folder nel file OML. Aspose.Email fornisce OlmFolder.Path proprietà che restituisce il percorso della cartella. Il seguente snippet di codice dimostra l’uso di OlmFolder.Path proprietà per ottenere i percorsi delle cartelle nel file 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);
        }
    }
}

Conta gli elementi nella cartella

Puoi anche contare il numero di elementi nella cartella. Aspose.Email fornisce OlmFolder.MessageCount proprietà che restituisce il numero di elementi nella cartella. Il seguente snippet di codice dimostra l’uso di OlmFolder.MessageCount proprietà per ottenere il numero di elementi nelle cartelle del file 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);
    }
}

Ottenere il conteggio totale degli elementi di OlmStorage

OlmStorage la classe ha anche GetTotalItemsCount() metodo che restituisce il numero totale di elementi di messaggio contenuti nell’archivio OLM.

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

Recupero dei colori delle categorie di Outlook

Per lavorare con i colori delle categorie o le categorie degli elementi Outlook memorizzate nei file OLM, Aspose.Email offre le seguenti soluzioni:

OlmItemCategory classe - rappresenta le categorie degli elementi di Outlook disponibili per nome e colori associati, rappresentati in formato esadecimale.
GetCategories() metodo del OlmStorage classe - recupera l’elenco delle categorie.

Il campione di codice seguente dimostra come ottenere tutte le categorie utilizzate dall’archivio 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}");
    }
}

Il campione di codice qui sotto mostra come ottenere il colore di una categoria di messaggio:

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

Converti OLM in PST

OLM è un formato di file database utilizzato da Microsoft Outlook per sistemi Mac. I file OLM memorizzano messaggi di posta elettronica, dati del calendario, dati dei contatti e impostazioni dell’applicazione. Un file OLM non è supportato da Outlook per Windows. Pertanto, non è possibile aprire un file Outlook per Mac (OLM) in Outlook per Windows. Se desideri migrare la tua casella di posta da Outlook per Mac a Outlook per Windows, è necessario convertire il file OLM di Outlook per Mac nel formato file PST di Outlook.

Passaggi del codice

Per convertire un file OLM in PST, segui i passaggi indicati sotto:

Crea un’istanza di OlmStorage classe per aprire l’OLM sorgente.
Apri un file OLM sorgente.
Crea un nuovo file PST usando Crea metodo.
Crea un metodo GetContainerClass per mappare la classe del messaggio a una classe di cartella.
Crea un metodo AddToPst che legge ricorsivamente ogni cartella e i suoi messaggi da OLM usando il metodo EnumerateMapiMessages e li aggiunge al PST nello stesso ordine usando i metodi AddSubFolder e AddMessage.

Esempio di codice

Il campione di codice seguente mostra come convertire OLM in PST.

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

Implementazione del metodo 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";
}

Implementazione del metodo 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);
    }
}

Lavorare con File PST di grandi dimensioni