Documentation – Lavorare con i file OLM

Net: Apertura di file OLM

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

Aspose.Email per .NET rappresenta un file di archiviazione Outlook per Mac con il OlmStorage classe. Questo articolo mostra come aprire un file OLM da un percorso o da uno stream, e come caricare in sicurezza un file che potrebbe essere danneggiato.

Apri un File OLM

Un file OLM può essere aperto in due modi:

usando un costruttore;
usando il metodo statico FromFile metodo.

Esiste una differenza di comportamento tra questi due approcci che influisce su come viene inizializzata la gerarchia delle cartelle. Vedi Navigazione delle cartelle OLM per i dettagli.

Usando il Costruttore

Per aprire un file, chiama il costruttore della OlmStorage classe e passa il nome completo del file come argomento. Poiché OlmStorage implementa IDisposable, avvolgilo in un using istruzione in modo che il handle del file sottostante venga rilasciato al termine.

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

Usando il Metodo Statico FromFile

Per aprire un file, usa il metodo statico FromFile metodo e passare il nome completo del file come argomento:

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

Apri un File OLM da uno Stream

Quando i dati OLM non provengono da un percorso locale - ad esempio, sono ricevuti da un database, una risorsa di rete o uno storage cloud - è possibile aprirli direttamente da un Stream. Usa il OlmStorage(Stream) costruttore o il metodo statico FromStream metodo.

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

Il metodo statico funziona allo stesso modo:

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

Mantieni aperto lo stream di origine finché accedi allo storage. Disporre lo stream prima di aver finito di leggere cartelle e messaggi causerà errori di lettura.

Apri un File OLM Corrotto

Se un file può essere parzialmente corrotto, è comunque possibile estrarre quanti più dati possibile senza fermarsi al primo errore. Per fare ciò, crea il OlmStorage istanza con il OlmStorage(TraversalExceptionsCallback callback) costruttore, quindi carica il file con il Load metodo invece del FromFile.

Il callback riceve le eccezioni sollevate durante il caricamento e l’attraversamento, così puoi registrarle o ignorarle. Il Load metodo restituisce true se il file è stato caricato correttamente e la traversa è possibile, e false se il file è troppo corrotto per essere attraversato.

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

Per un esempio completo di estrazione di elementi da un file danneggiato, vedi Lettura ed estrazione di messaggi OLM.

Net: Navigazione delle cartelle OLM

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

Un file OLM organizza i dati in un albero di cartelle, ognuna rappresentata da un OlmFolder oggetto. Questo articolo mostra come enumerare la gerarchia delle cartelle, recuperare una cartella specifica per nome, navigare tra le sottocartelle e leggere i percorsi delle cartelle.

Recupera la Gerarchia delle Cartelle

Una volta aperto il file, accedi alla sua struttura di directory tramite il FolderHierarchy proprietà. Questa proprietà restituisce un elenco di OlmFolder oggetti, ognuno rappresentante una directory di livello superiore nel file OLM. Per esplorare più a fondo, leggi il SubFolders proprietà di ciascuna cartella, che restituisce le sue sottodirectory. Usando questi due membri puoi attraversare l’intera gerarchia.

L’esempio sotto stampa tutte le cartelle in ordine gerarchico:

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 e il Metodo FromFile

Il modo in cui apri il file influisce su come FolderHierarchy si comporta:

Quando apri il file con il costruttore, il FolderHierarchy la proprietà viene inizializzata automaticamente.
Quando apri il file con il FromFile metodo, FolderHierarchy non è inizializzato per impostazione predefinita e restituisce null. In questo caso, chiama il GetFolders metodo esplicitamente per inizializzare la gerarchia e recuperare l’elenco delle directory:

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

Ottieni una Cartella per Nome

Per recuperare una singola cartella per nome, chiama il GetFolder metodo. Passa il nome della cartella come primo argomento e un booleano come secondo argomento che indica se il caso deve essere ignorato durante la ricerca.

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

Ottieni una Sottocartella per Nome

Ogni OlmFolder ti permette anche di individuare direttamente una sottocartella con il GetSubFolder metodo. Passa il nome della sottocartella e se il caso deve essere ignorato. Questo è utile quando possiedi già una cartella genitore e vuoi approfondire senza riesaminare l’intera gerarchia.

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

Recupera Percorsi delle Cartelle

Puoi leggere il percorso completo di qualsiasi cartella tramite il OlmFolder.Path proprietà. Il frammento seguente stampa il percorso di ogni cartella nel file:

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: Lettura ed estrazione di messaggi OLM

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

Dopo aver aperto un file OLM e individuato una cartella, è possibile elencare i suoi messaggi, leggere informazioni brevi sui messaggi, filtrare e paginare cartelle grandi, ed estrarre messaggi individuali come MapiMessage oggetti. Questo articolo copre tutte queste operazioni.

Elenca i Messaggi in una Cartella

Il OlmFolder classe fornisce due modalità per iterare sui messaggi che contiene:

EnumerateMessages restituisce un OlmMessageInfo oggetto in ogni iterazione. Questo oggetto contiene informazioni brevi sul messaggio ed è il modo più efficiente per scansionare una cartella.
EnumerateMapiMessages restituisce un MapiMessage oggetto in ogni iterazione, con tutte le proprietà del messaggio caricate.

Usando EnumerateMessages

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

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

Leggi le Informazioni del Messaggio

Ogni OlmMessageInfo l’oggetto espone un insieme di proprietà di sola lettura che descrivono un messaggio senza caricarne il contenuto completo. Questo è il modo più efficiente per costruire una visualizzazione a elenco o decidere quali messaggi estrarre.

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

Ottieni 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. Usa la OlmMessageInfo.ModifiedDate proprietà per leggerla:

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

Filtra Messaggi con una Query

Per cartelle grandi, puoi recuperare solo i messaggi che corrispondono a un insieme di criteri invece di iterare su tutto. Passa un MailQuery al EnumerateMessages(MailQuery query) sovraccarico. Costruisci la query con un MailQueryBuilder.

L’esempio sotto enumera solo i messaggi ricevuti negli ultimi sette giorni il cui oggetto contiene la parola "Fattura":

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

Scorri i Messaggi a Pagina

Quando una cartella contiene un gran numero di messaggi, puoi leggerli in blocchi con il EnumerateMessages(int skip, int count) sovraccarico. Il skip il parametro è il numero di messaggi da saltare, e count è il numero di messaggi da restituire.

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

Estrai un Messaggio come MapiMessage

Il OlmStorage classe fornisce il ExtractMapiMessage metodo, che estrae un messaggio completo MapiMessage da un OlmMessageInfo oggetto. Questo è utile quando prima scansioni una cartella con EnumerateMessages e poi estrarre solo i messaggi realmente necessari.

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

Estrai Messaggi per Identificatore

A volte è necessario estrarre messaggi selezionati tramite i loro identificatori. Per esempio, un’applicazione può memorizzare gli identificatori in un database e estrarre un messaggio su richiesta invece di attraversare l’intero storage ogni volta. Il EntryId proprietà di OlmMessageInfo fornisce l’identificatore di voce del messaggio, e il sovraccarico ExtractMapiMessage(string id) metodo recupera il messaggio per quell’identificatore.

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

Estrai Elementi Usando l’API di Traversa

Puoi estrarre ogni elemento da un file OLM - per quanto possibile - senza generare eccezioni, anche quando alcuni dati nel file originale sono corrotti. Per fare ciò, crea il OlmStorage istanza con il OlmStorage(TraversalExceptionsCallback callback) costruttore e carica il file con il Load metodo. La callback espone le eccezioni di caricamento e traversa.

Il Load metodo restituisce true se il file è stato caricato correttamente e la traversa è possibile, e false se il file è corrotto e non è possibile effettuare la traversa. Nota che quando si attraversano gli elementi cartella per cartella, chiami il metodo dello storage EnumerateMessages(OlmFolder folder) metodo, passando la cartella come argomento.

I passaggi sono:

Crea un nuovo OlmStorage istanza, passando una callback per la gestione delle eccezioni.
Carica il file OLM chiamando il Load metodo.
Se il file si carica correttamente, ottieni la gerarchia delle cartelle chiamando GetFolders.
Itera ricorsivamente su ogni cartella. Per le cartelle che contengono messaggi, enumera i messaggi con il metodo dello storage EnumerateMessages metodo e processa ognuna di esse.
Ricorri in tutte le sottocartelle.

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: Conteggio degli elementi e lavoro con le categorie

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

Oltre a leggere messaggi individuali, Aspose.Email per .NET ti consente di ispezionare quanti elementi contiene un file OLM o una cartella e leggere le categorie Outlook - inclusi i loro colori - archiviate nel file. Questo articolo copre entrambi gli aspetti.

Verifica se una Cartella Contiene Messaggi

Il OlmFolder.HasMessages proprietà indica se una cartella contiene messaggi, e il OlmFolder.MessageCount proprietà restituisce quanti.

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

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

Conta gli Elementi in Ogni Cartella

Usa il OlmFolder.MessageCount proprietà per segnalare il numero di elementi in ogni cartella del file:

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

Ottieni il Numero Totale di Elementi nello Storage

Il OlmStorage la classe ha un GetTotalItemsCount() metodo che restituisce il numero totale di elementi messaggio contenuti nell’intero storage OLM:

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

Recuperare i colori delle categorie di Outlook

Per lavorare con le categorie di elementi Outlook memorizzate in un file OLM, Aspose.Email offre:

il OlmItemCategory classe - rappresenta una categoria di elemento Outlook, disponibile tramite il suo Nome e associate Colore, rappresentato in formato esadecimale;
il GetCategories() metodo del OlmStorage classe - recupera l’elenco delle categorie usate nello storage.

Il campione seguente elenca tutte le categorie usate nello storage insieme al loro colore:

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

Ottieni il Colore della Categoria di un Messaggio

Puoi confrontare le categorie assegnate a un determinato messaggio con l’elenco delle categorie dello storage per determinare il colore di ciascuna. L’esempio seguente legge le categorie di ogni messaggio in una cartella e stampa il colore di ciascuna:

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: Conversione da OLM a PST

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

OLM è un formato di file di database usato da Microsoft Outlook per Mac. I file OLM memorizzano messaggi email, dati di calendario, contatti e impostazioni dell’applicazione, e non sono supportati da Outlook per Windows. Per migrare una casella di posta da Outlook per Mac a Outlook per Windows, devi convertire il file OLM nel formato Outlook PST formato. Aspose.Email per .NET ti permette di farlo con il codice, senza che Microsoft Outlook sia installato.

Come Funziona la Conversione

Per convertire un file OLM in PST, segui questi passaggi:

Crea un’istanza di OlmStorage classe per aprire il file OLM sorgente.
Crea un nuovo file PST con il PersonalStorage.Create metodo.
Implementa un GetContainerClass metodo che mappa una classe di messaggio alla corrispondente classe di cartella (contenitore), così ogni cartella viene creata con il tipo corretto nel PST.
Implementa un AddToPst metodo che legge ricorsivamente ogni cartella e i suoi messaggi dal file OLM - usando EnumerateMapiMessages - e li aggiunge al PST nello stesso ordine, usando il AddSubFolder e AddMessage metodi di FolderInfo.

Esempio di Codice

Il codice seguente mostra come convertire un file OLM in PST.

Metodo Main:

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

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

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

La conversione nella direzione opposta (da PST a OLM) non è supportata, perché un file OLM è sempre creato da Outlook per Mac quando un account viene aggiunto e sincronizzato con il server di posta.