Lectura y conversión de archivos Outlook

Trabajar con archivos OST

Aspose.Email para .NET proporciona una API para leer archivos OST de Microsoft Outlook. Puede cargar un archivo OST desde disco o un flujo en una instancia del Aspose.Email.Outlook.Pst.PersonalStorage clase para acceder a su contenido, como carpetas, subcarpetas y mensajes. Microsoft Outlook crea un archivo PST para almacenar correos electrónicos al usar servidores de correo POP3 o IMAP. En contraste, crea un archivo OST cuando Microsoft Exchange es el servidor de correo. Los archivos OST también admiten tamaños de archivo más grandes que los archivos PST.

Leer archivos OST

El proceso para leer un archivo OST con Aspose.Email es exactamente el mismo que para leer un archivo PST. El mismo código puede leer tanto archivos PST como OST: solo proporciona el nombre de archivo correcto al PersonalStorage.FromFile() método. El siguiente fragmento de código muestra cómo leer archivos OST.

Convertir OST a PST

¡Pruébalo!

Convierte correos y archivos de mensajes en línea con la versión gratuita Aplicación de Conversión Aspose.Email.

Aspose.Email permite convertir un archivo OST a PST con una sola línea de código. De manera similar, el archivo OST puede crearse a partir de un archivo PST usando la misma línea de código con el FileFormat enumerador. Actualmente, la API admite la conversión de formatos OST a PST excepto 2013/2016/2019/2021 y versiones futuras. El siguiente fragmento de código muestra cómo convertir OST a PST.

Para realizar otras operaciones con archivos OST, por favor consulta las siguientes páginas:

Convertir PST a OST

La conversión de PST a OST no está soportada por Aspose.Email porque el OST siempre es creado por Outlook al agregar una cuenta y sincronizar con el servidor de correo. La diferencia entre los archivos PST y OST es que PST solo está disponible localmente. El contenido OST también está disponible en el servidor de correo. Por lo tanto, no es necesario convertir PST a OST para uso local. Pero puedes importar un PST a una cuenta existente usando el asistente Importar/Exportar en Outlook.

OLM es un formato de archivo específico utilizado por Microsoft Outlook para almacenar datos locales como correos electrónicos, archivos adjuntos, notas, datos de calendario, contactos, tareas, historial y más. Los archivos OLM solo son compatibles con Outlook para Mac y no pueden abrirse o accederse mediante Outlook para Windows, que utiliza el formato de archivo PST.

Trabajando con archivos OLM

Abrir archivos OLM

Los archivos en formato OLM pueden abrirse de dos maneras:

usando el constructor
usando el método estático FromFile

Existen diferencias de comportamiento entre estos métodos. Consulte la sección a continuación.

Usando el constructor

Para abrir un archivo, llame al constructor de la OlmStorage clase y pase el nombre completo del archivo o stream como argumento a él:

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

Usando el método estático FromFile

Para abrir un archivo, utilice el método estático FromFile y pase el nombre completo del archivo o un flujo como argumento:

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

Recuperar carpetas

Para acceder a la estructura de directorios de un archivo OLM, cree una instancia de la OlmStorage clase usando su constructor y pase la ruta al archivo. Una vez abierto el archivo, acceda a su estructura de directorios usando el FolderHierarchy propiedad. Esta propiedad devuelve una lista de OlmFolder objetos, cada uno representando un directorio en el archivo OLM. Para explorar más la estructura de directorios, acceda al SubFolders propiedad de cada objeto, que devuelve una lista de sus subdirectorios. Al usar estas propiedades, puede navegar a través de toda la jerarquía de directorios del archivo OLM y acceder a todos los directorios y subdirectorios que contiene.

El ejemplo a continuación muestra la lista de todas las carpetas en orden jerárquico:

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

Al usar el FromFile método para abrir un archivo OLM, el FolderHierarchy la propiedad no se inicializará por defecto y devolverá null. En este caso, llame al método GetFolders explícitamente para inicializarla FolderHierarchy propiedad y recuperar la lista de directorios en el archivo OLM:

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

Además, es posible obtener cualquier carpeta por nombre:

Llame a GetFolder método.
Pase el nombre de la carpeta como primer argumento y el valor, que indica si se debe ignorar la sensibilidad a mayúsculas al buscar una carpeta, como segundo parámetro.

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

Listar correos electrónicos

OlmFolder clase, que representa una carpeta, tiene los siguientes métodos para obtener la lista de correos:

EnumerateMessages implementa la iteración de correos electrónicos en una carpeta. En este caso, cada iteración devuelve OlmMessageInfo objeto, que proporciona información breve sobre el correo electrónico.
EnumerateMapiMessages, también implementa la iteración de correos electrónicos en una carpeta, pero en este caso, cada iteración devuelve MapiMessage objeto, que representa el correo electrónico en sí, con todas sus propiedades.

Uso del método EnumerateMessages

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

Uso del método 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");
    }
}

Otras propiedades útiles

Las otras propiedades útiles de la clase OlmFolder son: HasMessages y MessageCount propiedades, que devuelven la presencia de mensajes en la carpeta y su recuento.

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

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

Obtener o establecer la fecha de modificación de un mensaje

La fecha de modificación representa la fecha y hora en que el mensaje OLM fue modificado por última vez. Puede usar el OlmMessageInfo.ModifiedDate propiedad para recuperar o actualizar el valor de la fecha de modificación de un mensaje OLM.

He aquí un ejemplo que demuestra el uso de la propiedad:

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

Extraer correos y elementos

OlmStorage clase tiene ExtractMapiMessage método que permite extraer correos electrónicos. Este método recibe un OlmMessageInfo objeto.

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

Usando API de recorrido

Puedes extraer todos los elementos de un archivo OLM de Outlook tanto como sea posible, sin lanzar excepciones, incluso si algunos datos del archivo original están corruptos. Para hacerlo, utiliza OlmStorage(TraversalExceptionsCallback callback) constructor y Load(string fileName) método en lugar del método FromFile. El constructor permite definir un método de devolución de llamada.

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

El método de devolución de llamada hace que las excepciones de carga y recorrido estén disponibles.

El Load el método devuelve ’true’ si el archivo se ha cargado correctamente y es posible continuar el recorrido. Si el archivo está corrupto y no es posible el recorrido, se devuelve ‘false’.

if (olm.Load(fileName))

El siguiente fragmento de código y los pasos muestran cómo usar esta API:

Crea una nueva instancia de la OlmStorage clase, pasando una función de devolución de llamada para el manejo de excepciones para gestionar cualquier excepción encontrada durante el proceso.
Carga el archivo OLM llamando al Load método de la instancia de OlmStorage.
Si el archivo OLM se carga correctamente, obtén la jerarquía de carpetas llamando al GetFolders método en la instancia de OlmStorage. Esto devuelve una lista de objetos OlmFolder.
Llama al método ExtractItems, pasando la instancia de OlmStorage y la lista de objetos OlmFolder.
En el método ExtractItems, itera a través de cada carpeta en la lista de carpetas.
Si la carpeta contiene mensajes (correos electrónicos), imprime el nombre de la carpeta en la consola usando Console.WriteLine(folder).
Itera a través de los mensajes en la carpeta actual llamando al método EnumerateMessages en la instancia de OlmStorage, pasando la carpeta actual como argumento.
Imprime el asunto de cada mensaje en la consola usando Console.WriteLine(msg.Subject).
Si la carpeta tiene subcarpetas, llama recursivamente al método ExtractItems nuevamente, pasando la instancia de OlmStorage y las subcarpetas de la carpeta actual.

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

Extraer mensajes por identificadores

A veces es necesario extraer mensajes seleccionados por identificadores. Por ejemplo, su aplicación almacena identificadores en una base de datos y extrae un mensaje bajo demanda. Esta es la manera eficiente de evitar recorrer todo el almacenamiento cada vez para encontrar un mensaje específico que extraer. Esta característica está disponible para los almacenamientos OLM. El EntryId propiedad del OlmMessageInfo clase obtiene el identificador de entrada del mensaje. La sobrecargada ExtractMapiMessage(string id) método del OlmStorage clase obtiene el mensaje de OLM.

El código a continuación muestra cómo extraer mensajes de OLM por identificadores.

El código realiza los siguientes pasos:

Inicia un bucle foreach para iterar a través de una lista de OlmMessageInfo objetos. El bucle usa el EnumerateMessages método del objeto olmFolder para recuperar una lista de todos los mensajes en la carpeta actual que se está iterando.
El bucle extrae el objeto MapiMessage correspondiente del almacenamiento llamando al ExtractMapiMessage(string id) método de OlmStorage clase, pasando el EntryId del mensaje actual como parámetro.

El objeto MapiMessage recuperado puede usarse para acceder y manipular el contenido del mensaje. El bucle continúa hasta que se hayan procesado todos los mensajes de la carpeta.

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

Recuperación de ruta de carpeta

También puede obtener la ruta de las carpetas en el archivo OML. Aspose.Email proporciona OlmFolder.Path propiedad que devuelve la ruta de la carpeta. El siguiente fragmento de código demuestra el uso de OlmFolder.Path propiedad para obtener las rutas de carpeta en el archivo 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);
        }
    }
}

Contar ítems en carpeta

También puede contar el número de elementos en la carpeta. Aspose.Email proporciona OlmFolder.MessageCount propiedad que devuelve el número de elementos en la carpeta. El siguiente fragmento de código demuestra el uso de OlmFolder.MessageCount propiedad para obtener el número de elementos en las carpetas del archivo 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);
    }
}

Obtener recuento total de elementos de OlmStorage

OlmStorage la clase también tiene GetTotalItemsCount() método que devuelve el número total de elementos de mensaje contenidos en el almacenamiento OLM.

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

Recuperación de colores de categorías de Outlook

Para trabajar con colores de categoría o categorías de elementos de Outlook almacenadas en archivos OLM, Aspose.Email ofrece las siguientes soluciones:

OlmItemCategory clase - representa categorías de elementos de Outlook disponibles por su nombre y colores asociados, representados en formato hexadecimal.
GetCategories() método del OlmStorage clase - recupera la lista de categorías.

El siguiente ejemplo de código demuestra cómo obtener todas las categorías usadas del almacenamiento 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}");
    }
}

El ejemplo de código a continuación muestra cómo obtener el color de la categoría de un mensaje:

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 a PST

OLM es un formato de archivo de base de datos usado por Microsoft Outlook para sistemas Mac. Los archivos OLM almacenan mensajes de correo, datos de calendario, datos de contactos y configuraciones de la aplicación. Un archivo OLM no es compatible con Outlook para Windows. Por lo tanto, no es posible abrir un archivo Outlook para Mac (OLM) en Outlook para Windows. Si desea migrar su buzón de Outlook para Mac a Outlook para Windows, es necesario convertir el archivo OLM de Outlook para Mac al formato de archivo PST de Outlook.

Pasos de código

Para convertir un archivo OLM a PST siga los pasos a continuación:

Cree una instancia de OlmStorage clase para abrir el OLM fuente.
Abra un archivo OLM fuente.
Cree un nuevo archivo PST usando Create método.
Cree un método GetContainerClass para mapear la clase de mensaje a una clase de carpeta.
Cree un método AddToPst que lea recursivamente cada carpeta y sus mensajes de OLM usando el método EnumerateMapiMessages y los añada al PST en el mismo orden usando los métodos AddSubFolder y AddMessage.

Ejemplo de código

El siguiente ejemplo de código muestra cómo convertir OLM a PST.

Método 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);
    }
}

Implementación del método 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";
}

Implementación del método 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);
    }
}

Trabajando con propiedades de protección de contraseña PST Leer archivos PST/OST corruptos