Cómo establecer conexiones IMAP en C#

Listado de extensiones del servidor IMAP

de Aspose.Email ImapClient permite recuperar las extensiones del servidor que admite, como IDLE, UNSELECT, QUOTA, etc. Esto ayuda a identificar la disponibilidad de una extensión antes de usar el cliente para esa funcionalidad particular. El GetCapabilities() método devuelve los tipos de extensiones soportadas en forma de arreglo de strings. El siguiente fragmento de código muestra cómo recuperar extensiones.

Conexión IMAP estándar

El ImapClient la clase permite a las aplicaciones gestionar buzones IMAP usando el protocolo IMAP. El ImapClient la clase se usa para conectar a servidores de correo IMAP y gestionar correos en las carpetas de email IMAP. Para conectar a un servidor IMAP

Cree una instancia de la ImapClient clase.
Especificar el nombre de host, nombre de usuario y contraseña en el constructor ImapClient.

Nota, las restricciones de contraseña deben cumplir con los requisitos del servidor. El cliente de correo no añade restricciones de contraseña.

Una vez que ImapClient se inicia la instancia, la siguiente llamada a cualquier operación usando esta instancia conectará al servidor. El siguiente fragmento de código muestra cómo conectarse a un servidor IMAP usando los pasos anteriores.

// 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("localhost", "user", "password");

Conexión IMAP con SSL habilitado

Conectándose con el servidor IMAP describe cómo conectarse a un servidor IMAP en cuatro simples pasos:

Cree una instancia de la ImapClient clase.
Especificar el nombre de host, nombre de usuario y contraseña.
Especificar el puerto.
Especifica las opciones de seguridad.

El proceso para conectarse a un servidor IMAP con SSL habilitado es similar pero requiere que configures algunas propiedades más:

Establecer SecurityOptions a SSLImplicit.

El siguiente fragmento de código muestra cómo

Establecer un nombre de usuario, contraseña y puerto.
Establecer opción de seguridad.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Create an instance of the ImapClient class
ImapClient client = new ImapClient("imap.domain.com", 993, "user@domain.com", "pwd");
            
// Set the security mode to implicit
client.SecurityOptions = SecurityOptions.SSLImplicit;

Configuración de conexión proxy

Conectando al servidor mediante proxy

Los servidores proxy se usan comúnmente para comunicarse con el exterior. En tales casos, los clientes de correo no pueden comunicarse por Internet sin especificar la dirección del proxy. Aspose.Email ofrece soporte para las versiones 4, 4a y 5 del protocolo proxy SOCKS. Este artículo proporciona un ejemplo funcional de acceso al buzón usando un servidor proxy de correo. Para acceder al buzón a través de un servidor proxy:

Inicializar SocksProxy con la información requerida, es decir, dirección del proxy, puerto y versión SOCKS.
Inicializar ImapClient con la dirección del host, nombre de usuario, contraseña y cualquier otra configuración.
Establecer el SocksProxy propiedad del cliente a la SocksProxy objeto creado arriba.

El siguiente fragmento de código muestra cómo recuperar el buzón a través de un servidor proxy.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Connect and log in to IMAP and set SecurityOptions
ImapClient client = new ImapClient("imap.domain.com", "username", "password");
client.SecurityOptions = SecurityOptions.Auto;
            
string proxyAddress = "192.168.203.142"; // proxy address
int proxyPort = 1080; // proxy port
SocksProxy proxy = new SocksProxy(proxyAddress, proxyPort, SocksVersion.SocksV5);

// Set the proxy
client.Proxy = proxy;
           
try
{
    client.SelectFolder("Inbox");
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

Conectándose al servidor vía proxy HTTP

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
HttpProxy proxy = new HttpProxy("18.222.124.59", 8080);
using (ImapClient client = new ImapClient("imap.domain.com", "username", "password"))
{
    client.Proxy = proxy;
    client.SelectFolder("Inbox");
}

Conexión en modo solo lectura

El ImapClient clase proporciona un ReadOnly propiedad que, cuando se establece en true, indica que no se deben hacer cambios en el estado permanente del buzón. El siguiente ejemplo de código demuestra el uso de ImapClient.ReadOnly propiedad. Obtiene el recuento de mensajes no leídos, luego recupera un mensaje y vuelve a obtener el recuento de mensajes no leídos en modo de solo lectura. El recuento de los mensajes no leídos permanece igual, lo que indica que el estado permanente del buzón no se modificó.

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

ImapQueryBuilder imapQueryBuilder = new ImapQueryBuilder();
imapQueryBuilder.HasNoFlags(ImapMessageFlags.IsRead); /* get unread messages. */
MailQuery query = imapQueryBuilder.GetQuery();

imapClient.ReadOnly = true;
imapClient.SelectFolder("Inbox");
ImapMessageInfoCollection messageInfoCol = imapClient.ListMessages(query);
Console.WriteLine("Initial Unread Count: " + messageInfoCol.Count());
if (messageInfoCol.Count() > 0)
{
    imapClient.FetchMessage(messageInfoCol[0].SequenceNumber);

    messageInfoCol = imapClient.ListMessages(query);
    // This count will be equal to the initial count
    Console.WriteLine("Updated Unread Count: " + messageInfoCol.Count());
}
else
{
    Console.WriteLine("No unread messages found");
}

Configuración de autenticación CRAM-MD5

Para una autenticación segura y acceso al servidor de correo, Aspose.Email para .NET ofrece el método de autenticación CRAM-MD5. El siguiente fragmento de código mostrará cómo funciona con ImapClient:

imapClient.AllowedAuthentication = ImapKnownAuthenticationType.CramMD5;

Estableciendo tiempos de espera para operaciones IMAP

Cada operación de correo lleva tiempo dependiendo de muchos factores (retardos de red, tamaño de datos, rendimiento del servidor, etc.). Puede establecer un tiempo de espera para todas las operaciones de correo. El ejemplo de código a continuación le muestra cómo hacerlo usando el Tiempo de espera propiedad. Nota: no debe establecer valores grandes para evitar largas esperas en su aplicación.

Configurar tiempo de espera de operación

using (ImapClient imapClient = new ImapClient("host", 993, "username", "password", SecurityOptions.SSLImplicit))
{
    imapClient.Timeout = 60000; // 60 seconds

    // some code...
}

Restringir el tiempo de espera de saludo

El cliente IMAP puede usar el modo automático para establecer una conexión. En este modo, el cliente IMAP recorre todos los parámetros de conexión posibles hasta que la conexión se establece. Un servidor IMAP, en caso de conexión correcta, envía una cadena de saludo al cliente. Los servidores pueden usar iniciación de conexión SSL/TLS implícita o explícita (START TLS). Si el modo de conexión no coincide (por ejemplo, el servidor espera una conexión SSL implícita pero el cliente intenta establecer una conexión no segura o SSL explícita), el servidor no enviará la cadena de saludo y el usuario esperará mucho tiempo hasta que el tiempo de espera alcance la cadena de saludo, y el cliente pasará a la siguiente opción de conexión. Para evitar este problema, se introdujo la propiedad GreetingTimeout. Esta propiedad permite establecer el tiempo de espera para la cadena de saludo y reducir el tiempo de establecimiento automático de la conexión.

using (ImapClient client = new ImapClient("localhost", 993, "username", "password"))
{
    client.GreetingTimeout = 4000;
    client.SelectFolder(ImapFolderInfo.InBox);
}

Uso de protocolos criptográficos con IMAP

Aspose.Email soporta los protocolos criptográficos SSL (obsoleto) y TLS para proporcionar seguridad en las comunicaciones. Puede habilitar el cifrado criptográfico para proteger el intercambio de datos entre su aplicación y los servidores de correo.

NOTA: Debe establecer solo aquellas versiones del protocolo que sean soportadas por .NET Framework. Si algunas versiones del protocolo criptográfico no son compatibles con su versión actual de .NET Framework, serán ignoradas y omitidas. En este caso, no se generarán excepciones. Por favor use SetSupportedEncryptionUnsafe método si desea establecer los protocolos sin ninguna verificación de compatibilidad.

El ejemplo de código a continuación le muestra cómo establecer TLS 1.3 para ImapClient instancia de clase.

using (ImapClient imapClient = new ImapClient("host", 993, "username", "password", SecurityOptions.SSLImplicit))
{
    imapClient.SupportedEncryption = EncryptionProtocols.Tls13;

    // some code...
}

En caso de que un protocolo de cifrado especificado no sea compatible con la versión actual de .NET Framework, la diferencia en el comportamiento entre SetSupportedEncryptionUnsafe método y SupportedEncryption propiedad es la siguiente:

Si SupportedEncryption propiedad se usa, el cliente de correo degrada el protocolo de cifrado a un nivel soportado.
Si SetSupportedEncryptionUnsafe método se usa, el cliente de correo lanza excepciones.

Uso del comando IMAP IDLE

API de Aspoe.Email ImapClient proporciona la capacidad de abrir una conexión al servidor y esperar la llegada de un mensaje de correo. Esto permite evitar sondear el servidor una y otra vez por correo entrante. El siguiente fragmento de código demuestra cómo usar la biblioteca Aspose.Email para monitorizar una bandeja de entrada IMAP en busca de nuevos mensajes y mensajes eliminados, y luego ejecutar acciones específicas basadas en estos eventos:

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Connect and log in to IMAP 
ImapClient client = new ImapClient("imap.domain.com", "username", "password");

ManualResetEvent manualResetEvent = new ManualResetEvent(false);
ImapMonitoringEventArgs eventArgs = null;
client.StartMonitoring(delegate(object sender, ImapMonitoringEventArgs e)
{
    eventArgs = e;
    manualResetEvent.Set();
});
Thread.Sleep(2000);
SmtpClient smtpClient = new SmtpClient("exchange.aspose.com", "username", "password");
smtpClient.Send(new MailMessage("from@aspose.com", "to@aspose.com", "EMAILNET-34875 - " + Guid.NewGuid(), "EMAILNET-34875 Support for IMAP idle command"));
manualResetEvent.WaitOne(10000);
manualResetEvent.Reset();
Console.WriteLine(eventArgs.NewMessages.Length);
Console.WriteLine(eventArgs.DeletedMessages.Length);
client.StopMonitoring("Inbox");
smtpClient.Send(new MailMessage("from@aspose.com", "to@aspose.com", "EMAILNET-34875 - " + Guid.NewGuid(), "EMAILNET-34875 Support for IMAP idle command"));
manualResetEvent.WaitOne(5000);

El siguiente ejemplo de código muestra cómo configurar la monitorización asíncrona de nuevos mensajes de correo:

var client = = new ImapClient("imap.domain.com", "username", "password");

//anySuccess is a flag to prevent infinite Client.ResumeMonitoring calls
var anySuccess = false;
await client.StartMonitoringAsync(OnNewMessagesCallback, OnErrorCallback);

void OnErrorCallback(object eventSender, ImapMonitoringErrorEventArgs errorEventArguments)
{
    //The exception can be handled here
    Logger.Debug.Write(
        $"An error occured while folder monitoring: {errorEventArguments.FolderName}",
        errorEventArguments.Error);
    //IMAP folder monitoring is stopped on any error. Here is an example
    //of resuming after that.
    if (!anySuccess) return;
    anySuccess = false;
    //Make sure you use ResumeMonitoring instead of StartMonitoring here
    //to prevent missing any emails between the error handling and resuming.
    client.ResumeMonitoring(OnNewMessagesCallback, OnErrorCallback,
        errorEventArguments.MonitoringState);
}

void OnNewMessagesCallback(object sender, ImapMonitoringEventArgs successEventArgs)
{
    anySuccess = true;
    //Use successEventArgs.NewMessages to handle new messages
    //Use successEventArgs.DeletedMessages to handle deleted messages
}

Soporte para extensiones IMAP

La API Aspose.Email brinda soporte para extensiones IMAP. Las siguientes extensiones IMAP son compatibles con la API en la actualidad. Estas extensiones IMAP no son compatibles con todos los servidores.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
using (ImapClient client = new ImapClient("imap.gmail.com", 993, "username", "password"))
{
    // Set SecurityOptions
    client.SecurityOptions = SecurityOptions.Auto;
    Console.WriteLine(client.IdSupported.ToString());

    ImapIdentificationInfo serverIdentificationInfo1 = client.IntroduceClient();
    ImapIdentificationInfo serverIdentificationInfo2 = client.IntroduceClient(ImapIdentificationInfo.DefaultValue);

    // Display ImapIdentificationInfo properties
    Console.WriteLine(serverIdentificationInfo1.ToString(), serverIdentificationInfo2);
    Console.WriteLine(serverIdentificationInfo1.Name);
    Console.WriteLine(serverIdentificationInfo1.Vendor);
    Console.WriteLine(serverIdentificationInfo1.SupportUrl);
    Console.WriteLine(serverIdentificationInfo1.Version);
}

Comando de lista extendida IMAP4

El siguiente fragmento de código le muestra cómo usar el comando de lista extendida IMAP4.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
using (ImapClient client = new ImapClient("imap.gmail.com", 993, "username", "password"))
{
    ImapFolderInfoCollection folderInfoCol = client.ListFolders("*");
    Console.WriteLine("Extended List Supported: " + client.ExtendedListSupported);
    foreach (ImapFolderInfo folderInfo in folderInfoCol)
    {
        switch (folderInfo.Name)
        {
            case "[Gmail]/All Mail":
                Console.WriteLine("Has Children: " + folderInfo.HasChildren);
                break;
            case "[Gmail]/Bin":
                Console.WriteLine("Bin has children? " + folderInfo.HasChildren);
                break;
            case "[Gmail]/Drafts":
                Console.WriteLine("Drafts has children? " + folderInfo.HasChildren);
                break;
            case "[Gmail]/Important":
                Console.WriteLine("Important has Children? " + folderInfo.HasChildren);
                break;
            case "[Gmail]/Sent Mail":
                Console.WriteLine("Sent Mail has Children? " + folderInfo.HasChildren);
                break;
            case "[Gmail]/Spam":
                Console.WriteLine("Spam has Children? " + folderInfo.HasChildren);
                break;
            case "[Gmail]/Starred":
                Console.WriteLine("Starred has Children? " + folderInfo.HasChildren);
                break;
        }
    }
}

Gestionar mensajes en el servidor IMAP