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:
- Crear una instancia de la clase ImapClient.
- Especificar un nombre de host, puerto, nombre de usuario y contraseña en el constructor de ImapClient.
- Seleccionar la carpeta utilizando el método SelectFolder().
- Llamar al método ListMessages para obtener el objeto ImapMessageInfoCollection.
- 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:
-
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.
-
Itera a través de cada mensaje en la messageInfoCollection utilizando un bucle foreach.
-
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.
-
Itera a través de cada adjunto en la attachmentInfoCollection utilizando un bucle foreach.
-
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); | |
} |