Trabajando con Mensajes del Servidor IMAP

Obtención de la información de identificación para mensajes recibidos de un buzón de correo

Al recuperar y procesar mensajes de correo electrónico, puedes obtener los detalles de esos mensajes utilizando sus números de secuencia. Las siguientes características se utilizan para interactuar con un buzón de correo IMAP:

  • Aspose.Email.MailboxInfo clase - Representa información de identificación sobre un mensaje en un buzón de correo.

    • Aspose.Email.MailboxInfo.SequenceNumber propiedad - El número de secuencia de un mensaje.

    • Aspose.Email.MailboxInfo.UniqueId propiedad - El ID único de un mensaje.

  • Aspose.Email.MailMessage.ItemId propiedad - Representa información de identificación sobre el mensaje en un buzón de correo.

El siguiente fragmento de código muestra cómo obtener información de identificación sobre los mensajes:

using (var client = new ImapClient(imapHost, port, emailAddress, password, securityOption))
{
    var msgs = client.ListMessages("INBOX").Take(5);
    var seqIds = msgs.Select(t => t.SequenceNumber);
    var msgsViaFetch = client.FetchMessages(seqIds);
    
    for (var i = 0; i < 5; i++)
    {
        var thisMsg = msgsViaFetch[i];
        Console.WriteLine($"Message ID:{seqIds.ElementAt(i)} SequenceNumber: {thisMsg.ItemId.SequenceNumber} Subject:{thisMsg.Subject}");
    }
}

Listado de IDs de Mensajes MIME desde el Servidor

ImapMessageInfo proporciona el MessageId MIME para la identificación de mensajes sin extraer el mensaje completo. El siguiente fragmento de código muestra cómo listar el mensaje MIMEId.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
ImapClient client = new ImapClient();
client.Host = "domain.com";
client.Username = "username";
client.Password = "password";
try
{
ImapMessageInfoCollection messageInfoCol = client.ListMessages("Inbox");
foreach (ImapMessageInfo info in messageInfoCol)
{
// Display MIME Message ID
Console.WriteLine("Message Id = " + info.MessageId);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}

Listado de Mensajes desde el Servidor

Aspose.Email proporciona una variante sobrecargada de 2 miembros de ListMessages() para recuperar un número especificado de mensajes basado en una consulta. El siguiente fragmento de código muestra cómo listar mensajes.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
imapClient.SelectFolder("Inbox");
ImapQueryBuilder builder = new ImapQueryBuilder();
MailQuery query =
builder.Or(
builder.Or(
builder.Or(
builder.Or(
builder.Subject.Contains(" (1) "),
builder.Subject.Contains(" (2) ")),
builder.Subject.Contains(" (3) ")),
builder.Subject.Contains(" (4) ")),
builder.Subject.Contains(" (5) "));
ImapMessageInfoCollection messageInfoCol4 = imapClient.ListMessages(query, 4);
Console.WriteLine((messageInfoCol4.Count == 4) ? "Success" : "Failure");

Listado de Mensajes desde el Servidor Recursivamente

El protocolo IMAP soporta el listado de mensajes recursivamente desde una carpeta de buzón. Esto ayuda a listar mensajes de subcarpetas de una carpeta también. El siguiente fragmento de código muestra cómo listar mensajes recursivamente.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Create an imapclient with host, user and password
ImapClient client = new ImapClient();
client.Host = "domain.com";
client.Username = "username";
client.Password = "password";
client.SelectFolder("InBox");
ImapMessageInfoCollection msgsColl = client.ListMessages(true);
Console.WriteLine("Total Messages: " + msgsColl.Count);

Listado de Mensajes con MultiConexión

ImapClient proporciona una propiedad UseMultiConnection que se puede usar para crear múltiples conexiones para operaciones pesadas. También puedes establecer el número de conexiones que se utilizarán durante el modo de multi-conexión usando ImapClient.ConnectionsQuantity. El siguiente fragmento de código demuestra el uso del modo de multi-conexión para listar mensajes y compara su rendimiento con el modo de conexión única.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
ImapClient imapClient = new ImapClient();
imapClient.Host = "<HOST>";
imapClient.Port = 993;
imapClient.Username = "<USERNAME>";
imapClient.Password = "<PASSWORD>";
imapClient.SupportedEncryption = EncryptionProtocols.Tls;
imapClient.SecurityOptions = SecurityOptions.SSLImplicit;
imapClient.SelectFolder("Inbox");
imapClient.ConnectionsQuantity = 5;
imapClient.UseMultiConnection = MultiConnectionMode.Enable;
DateTime multiConnectionModeStartTime = DateTime.Now;
ImapMessageInfoCollection messageInfoCol1 = imapClient.ListMessages(true);
TimeSpan multiConnectionModeTimeSpan = DateTime.Now - multiConnectionModeStartTime;
imapClient.UseMultiConnection = MultiConnectionMode.Disable;
DateTime singleConnectionModeStartTime = DateTime.Now;
ImapMessageInfoCollection messageInfoCol2 = imapClient.ListMessages(true);
TimeSpan singleConnectionModeTimeSpan = DateTime.Now - singleConnectionModeStartTime;
double performanceRelation = singleConnectionModeTimeSpan.TotalMilliseconds / multiConnectionModeTimeSpan.TotalMilliseconds;
Console.WriteLine("Performance Relation: " + performanceRelation);

Obtener Mensajes en orden descendente

Aspose.Email proporciona el método ImapClient.ListMessagesByPage que lista mensajes con soporte de paginación. Algunas sobrecargas de ImapClient.ListMessagesByPage aceptan PageSettings como parámetro. PageSettings proporciona una propiedad AscendingSorting que, cuando se establece en false, devuelve correos electrónicos en orden descendente.

El siguiente código de ejemplo demuestra el uso de la propiedad AscendingSorting de la PageSettings clase para cambiar el orden de los correos electrónicos.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
ImapClient imapClient = new ImapClient();
imapClient.Host = "<HOST>";
imapClient.Port = 993;
imapClient.Username = "<USERNAME>";
imapClient.Password = "<PASSWORD>";
imapClient.SupportedEncryption = EncryptionProtocols.Tls;
imapClient.SecurityOptions = SecurityOptions.SSLImplicit;
PageSettings pageSettings = new PageSettings { AscendingSorting = false };
ImapPageInfo pageInfo = imapClient.ListMessagesByPage(5, pageSettings);
ImapMessageInfoCollection messages = pageInfo.Items;
foreach (ImapMessageInfo message in messages)
{
Console.WriteLine(message.Subject + " -> " + message.Date.ToString());
}

Recuperar Mensajes del Servidor y Guardar en el disco

La clase ImapClient puede recuperar mensajes de un servidor IMAP y guardar los mensajes en formato EML en un disco local. Los siguientes pasos son necesarios para guardar los mensajes en el disco:

  1. Crear una instancia de la clase ImapClient.
  2. Especificar un nombre de host, puerto, nombre de usuario y contraseña en el constructor de ImapClient.
  3. Seleccionar la carpeta utilizando el método SelectFolder().
  4. Llamar al método ListMessages para obtener el objeto ImapMessageInfoCollection.
  5. Iterar a través de la colección ImapMessageInfoCollection, llamar al método SaveMessage() y proporcionar la ruta de salida y el nombre del archivo.

El siguiente fragmento de código muestra cómo recuperar mensajes de correo electrónico de un servidor y guardarlos.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Select the inbox folder and Get the message info collection
client.SelectFolder(ImapFolderInfo.InBox);
ImapMessageInfoCollection list = client.ListMessages();
// Download each message
for (int i = 0; i < list.Count; i++)
{
// Save the EML file locally
client.SaveMessage(list[i].UniqueId, dataDir + list[i].UniqueId + ".eml");
}

Guardando Mensajes en Formato MSG

En el ejemplo anterior, los correos electrónicos se guardan en formato EML. Para guardar correos electrónicos en formato MSG, se debe llamar al método ImapClient.FetchMessage(). Devuelve el mensaje en una instancia de la clase MailMessage. Luego se puede llamar al método MailMessage.Save() para guardar el mensaje en MSG. El siguiente fragmento de código muestra cómo guardar mensajes en formato MSG.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// The path to the file directory.
string dataDir = RunExamples.GetDataDir_IMAP();
// Create an imapclient with host, user and password
ImapClient client = new ImapClient("localhost", "user", "password");
// Select the inbox folder and Get the message info collection
client.SelectFolder(ImapFolderInfo.InBox);
ImapMessageInfoCollection list = client.ListMessages();
// Download each message
for (int i = 0; i < list.Count; i++)
{
// Save the message in MSG format
MailMessage message = client.FetchMessage(list[i].UniqueId);
message.Save(dataDir + list[i].UniqueId + "_out.msg", SaveOptions.DefaultMsgUnicode);
}

Grupo de Recuperación de Mensajes

ImapClient proporciona un método FetchMessages que acepta una lista de números de secuencia o ID únicos y devuelve una lista de MailMessage. El siguiente fragmento de código demuestra el uso del método FetchMessages para recuperar mensajes por números de secuencia y ID únicos.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
ImapClient imapClient = new ImapClient();
imapClient.Host = "<HOST>";
imapClient.Port = 993;
imapClient.Username = "<USERNAME>";
imapClient.Password = "<PASSWORD>";
imapClient.SupportedEncryption = EncryptionProtocols.Tls;
imapClient.SecurityOptions = SecurityOptions.SSLImplicit;
ImapMessageInfoCollection messageInfoCol = imapClient.ListMessages();
Console.WriteLine("ListMessages Count: " + messageInfoCol.Count);
int[] sequenceNumberAr = messageInfoCol.Select((ImapMessageInfo mi) => mi.SequenceNumber).ToArray();
string[] uniqueIdAr = messageInfoCol.Select((ImapMessageInfo mi) => mi.UniqueId).ToArray();
IList<MailMessage> fetchedMessagesBySNumMC = imapClient.FetchMessages(sequenceNumberAr);
Console.WriteLine("FetchMessages-sequenceNumberAr Count: " + fetchedMessagesBySNumMC.Count);
IList<MailMessage> fetchedMessagesByUidMC = imapClient.FetchMessages(uniqueIdAr);
Console.WriteLine("FetchMessages-uniqueIdAr Count: " + fetchedMessagesByUidMC.Count);

Listado de Mensajes con Soporte de Paginación

En escenarios donde el servidor de correo electrónico contiene una gran cantidad de mensajes en el buzón, a menudo se desea listar o recuperar los mensajes con soporte de paginación. La API Aspose.Email ImapClient te permite recuperar los mensajes del servidor con soporte de paginación.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
///<summary>
/// This example shows the paging support of ImapClient for listing messages from the server
/// Available in Aspose.Email for .NET 6.4.0 and onwards
///</summary>
using (ImapClient client = new ImapClient("host.domain.com", 993, "username", "password"))
{
try
{
int messagesNum = 12;
int itemsPerPage = 5;
MailMessage message = null;
// Create some test messages and append these to server's inbox
for (int i = 0; i < messagesNum; i++)
{
message = new MailMessage(
"from@domain.com",
"to@domain.com",
"EMAILNET-35157 - " + Guid.NewGuid(),
"EMAILNET-35157 Move paging parameters to separate class");
client.AppendMessage(ImapFolderInfo.InBox, message);
}
// List messages from inbox
client.SelectFolder(ImapFolderInfo.InBox);
ImapMessageInfoCollection totalMessageInfoCol = client.ListMessages();
// Verify the number of messages added
Console.WriteLine(totalMessageInfoCol.Count);
////////////////// RETREIVE THE MESSAGES USING PAGING SUPPORT////////////////////////////////////
List<ImapPageInfo> pages = new List<ImapPageInfo>();
PageSettings pageSettings = new PageSettings();
ImapPageInfo pageInfo = client.ListMessagesByPage(itemsPerPage, 0, pageSettings);
Console.WriteLine(pageInfo.TotalCount);
pages.Add(pageInfo);
while (!pageInfo.LastPage)
{
pageInfo = client.ListMessagesByPage(itemsPerPage, pageInfo.NextPage.PageOffset, pageSettings);
pages.Add(pageInfo);
}
int retrievedItems = 0;
foreach (ImapPageInfo folderCol in pages)
retrievedItems += folderCol.Items.Count;
Console.WriteLine(retrievedItems);
}
finally
{
}
}

Listado de los Adjuntos de Mensajes

Para obtener información sobre los adjuntos, como nombre y tamaño, sin recuperar los datos del adjunto, prueba las siguientes APIs:

  • Aspose.Email.Clients.Imap.ImapAttachmentInfo - Representa información sobre un adjunto.
  • Aspose.Email.Clients.Imap.ImapAttachmentInfoCollection - Representa una colección de la clase ImapAttachmentInfo.
  • Aspose.Email.Clients.Imap.ListAttachments(int sequenceNumber) - Obtiene información para cada adjunto en un mensaje.

El código de ejemplo con los pasos a continuación te mostrará cómo usar las APIs:

  1. Llama al método ListMessages() en el objeto imapClient. Este método devolverá una colección ImapMessageInfoCollection que contiene información sobre los mensajes en el buzón.

  2. Itera a través de cada mensaje en la messageInfoCollection utilizando un bucle foreach.

  3. Llama al método ListAttachments() en el objeto imapClient, pasando la propiedad SequenceNumber del objeto mensaje como parámetro. Este método devolverá una ImapAttachmentInfoCollection que contiene información sobre los adjuntos en el mensaje.

  4. Itera a través de cada adjunto en la attachmentInfoCollection utilizando un bucle foreach.

  5. Dentro del bucle interno, puedes acceder a la información sobre cada adjunto utilizando las propiedades del objeto attachmentInfo. En este ejemplo, el nombre y el tamaño de cada adjunto se registran en la consola utilizando Console.WriteLine().

    Console.WriteLine("Adjunto: {0} (tamaño: {1})", attachmentInfo.Name, attachmentInfo.Size);

var messageInfoCollection = imapClient.ListMessages();
    
foreach (var message in messageInfoCollection)
{
    var attachmentInfoCollection = imapClient.ListAttachments(message.SequenceNumber);

    foreach (var attachmentInfo in attachmentInfoCollection)
    {
        Console.WriteLine("Adjunto: {0} (tamaño: {1})", attachmentInfo.Name, attachmentInfo.Size);
    }
}

Obteniendo Carpetas y Leyendo Mensajes Recursivamente

En este artículo, se utilizan la mayoría de las características de ImapClient para crear una aplicación que liste todas las carpetas y subcarpetas recursivamente desde un servidor IMAP. También guarda los mensajes en cada carpeta y subcarpeta en formato MSG en un disco local. En el disco, las carpetas y los mensajes se crean y guardan en la misma estructura jerárquica que en el servidor IMAP. El siguiente fragmento de código muestra cómo obtener la información de los mensajes y subcarpetas de forma recursiva.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
public static void Run()
{
// Create an instance of the ImapClient class
ImapClient client = new ImapClient();
// Specify host, username, password, Port and SecurityOptions for your client
client.Host = "imap.gmail.com";
client.Username = "your.username@gmail.com";
client.Password = "your.password";
client.Port = 993;
client.SecurityOptions = SecurityOptions.Auto;
try
{
// The root folder (which will be created on disk) consists of host and username
string rootFolder = client.Host + "-" + client.Username;
// Create the root folder and List all the folders from IMAP server
Directory.CreateDirectory(rootFolder);
ImapFolderInfoCollection folderInfoCollection = client.ListFolders();
foreach (ImapFolderInfo folderInfo in folderInfoCollection)
{
// Call the recursive method to read messages and get sub-folders
ListMessagesInFolder(folderInfo, rootFolder, client);
}
// Disconnect to the remote IMAP server
client.Dispose();
}
catch (Exception ex)
{
Console.Write(Environment.NewLine + ex);
}
Console.WriteLine(Environment.NewLine + "Downloaded messages recursively from IMAP server.");
}
/// Recursive method to get messages from folders and sub-folders
private static void ListMessagesInFolder(ImapFolderInfo folderInfo, string rootFolder, ImapClient client)
{
// Create the folder in disk (same name as on IMAP server)
string currentFolder = RunExamples.GetDataDir_IMAP();
Directory.CreateDirectory(currentFolder);
// Read the messages from the current folder, if it is selectable
if (folderInfo.Selectable)
{
// Send status command to get folder info
ImapFolderInfo folderInfoStatus = client.GetFolderInfo(folderInfo.Name);
Console.WriteLine(folderInfoStatus.Name + " folder selected. New messages: " + folderInfoStatus.NewMessageCount + ", Total messages: " + folderInfoStatus.TotalMessageCount);
// Select the current folder and List messages
client.SelectFolder(folderInfo.Name);
ImapMessageInfoCollection msgInfoColl = client.ListMessages();
Console.WriteLine("Listing messages....");
foreach (ImapMessageInfo msgInfo in msgInfoColl)
{
// Get subject and other properties of the message
Console.WriteLine("Subject: " + msgInfo.Subject);
Console.WriteLine("Read: " + msgInfo.IsRead + ", Recent: " + msgInfo.Recent + ", Answered: " + msgInfo.Answered);
// Get rid of characters like ? and :, which should not be included in a file name and Save the message in MSG format
string fileName = msgInfo.Subject.Replace(":", " ").Replace("?", " ");
MailMessage msg = client.FetchMessage(msgInfo.SequenceNumber);
msg.Save(currentFolder + "\\" + fileName + "-" + msgInfo.SequenceNumber + ".msg", SaveOptions.DefaultMsgUnicode);
}
Console.WriteLine("============================\n");
}
else
{
Console.WriteLine(folderInfo.Name + " is not selectable.");
}
try
{
// If this folder has sub-folders, call this method recursively to get messages
ImapFolderInfoCollection folderInfoCollection = client.ListFolders(folderInfo.Name);
foreach (ImapFolderInfo subfolderInfo in folderInfoCollection)
{
ListMessagesInFolder(subfolderInfo, rootFolder, client);
}
}
catch (Exception) { }
}

Recuperando Parámetros Adicionales como Información Resumida

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
using (ImapClient client = new ImapClient("host.domain.com", "username", "password"))
{
MailMessage message = new MailMessage("from@domain.com", "to@doman.com", "EMAILNET-38466 - " + Guid.NewGuid().ToString(), "EMAILNET-38466 Add extra parameters for UID FETCH command");
// append the message to the server
string uid = client.AppendMessage(message);
// wait for the message to be appended
Thread.Sleep(5000);
// Define properties to be fetched from server along with the message
string[] messageExtraFields = new string[] { "X-GM-MSGID", "X-GM-THRID" };
// retreive the message summary information using it's UID
ImapMessageInfo messageInfoUID = client.ListMessage(uid, messageExtraFields);
// retreive the message summary information using it's sequence number
ImapMessageInfo messageInfoSeqNum = client.ListMessage(1, messageExtraFields);
// List messages in general from the server based on the defined properties
ImapMessageInfoCollection messageInfoCol = client.ListMessages(messageExtraFields);
ImapMessageInfo messageInfoFromList = messageInfoCol[0];
// verify that the parameters are fetched in the summary information
foreach (string paramName in messageExtraFields)
{
Console.WriteLine(messageInfoFromList.ExtraParameters.ContainsKey(paramName));
Console.WriteLine(messageInfoUID.ExtraParameters.ContainsKey(paramName));
Console.WriteLine(messageInfoSeqNum.ExtraParameters.ContainsKey(paramName));
}
}

Obteniendo Información de Encabezado List-Unsubscribe

El encabezado List-Unsubscribe contiene la URL para darse de baja de listas de correo electrónico, por ejemplo, publicidad, boletines, etc. Para obtener el encabezado List-Unsubscribe, utiliza la propiedad ListUnsubscribe de la clase ImapMessageInfo. El siguiente ejemplo muestra el uso de la propiedad ListUnsubscribe para obtener el encabezado List-Unsubscribe.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
ImapClient imapClient = new ImapClient();
imapClient.Host = "<HOST>";
imapClient.Port = 993;
imapClient.Username = "<USERNAME>";
imapClient.Password = "<PASSWORD>";
imapClient.SupportedEncryption = EncryptionProtocols.Tls;
imapClient.SecurityOptions = SecurityOptions.SSLImplicit;
ImapMessageInfoCollection messageInfoCol = imapClient.ListMessages();
foreach (ImapMessageInfo imapMessageInfo in messageInfoCol)
{
Console.WriteLine("ListUnsubscribe Header: " + imapMessageInfo.ListUnsubscribe);
}