Cómo realizar operaciones IMAP asíncronas en correos electrónicos

Operaciones asíncronas con ImapClient

Trabajar con mensajes puede realizarse de forma asíncrona usando Aspose.Email ImapClient. Este artículo muestra cómo recuperar mensajes de un buzón de forma asíncrona. También muestra cómo listar mensajes proporcionando criterios de búsqueda usando MailQuery. Se mostrará por separado cómo interrumpir una operación con mensajes de correo iniciada por un patrón asíncrono basado en tareas (TAP) método.

Recuperar mensajes de forma asíncrona

El siguiente fragmento de código muestra cómo recuperar mensajes de forma asíncrona.

Listar mensajes de forma asíncrona con MailQuery

El MailQuery La clase se puede usar para especificar criterios de búsqueda para recuperar una lista determinada de mensajes de forma asíncrona, como se muestra en el siguiente ejemplo de código.

Enviar mensajes de forma asíncrona

Enviar correos electrónicamente de forma asíncrona es muy conveniente, ya que el proceso no bloquea la ejecución del programa o hilo. En lugar de esperar a que el correo se envíe antes de continuar con otras tareas, el programa puede seguir ejecutándose mientras el correo se envía en segundo plano.

Las siguientes características le ayudarán a implementar el envío asíncrono en su proyecto:

• IAsyncImapClient - Permite a las aplicaciones acceder y manipular mensajes usando el Protocolo de Acceso a Mensajes de Internet (IMAP).

• ImapClient.CreateAsync - Crea una nueva instancia de la clase Aspose.Email.Clients.Imap.ImapClient

El ejemplo de código a continuación muestra cómo listar mensajes en segundo plano:

// Authenticate the client to obtain necessary permissions
static readonly string tenantId = "YOU_TENANT_ID";
static readonly string clientId = "YOU_CLIENT_ID";
static readonly string redirectUri = "http://localhost";
static readonly string username = "username";
static readonly string[] scopes = { "https://outlook.office.com/IMAP.AccessAsUser.All" };

// Use the ImapAsync method for asynchronous operations
static async Task Main(string[] args)
{
    await ImapAsync();
    Console.ReadLine();
}

// Establish the connection with the server
// Create an instance of the ImapClient asynchronously using the CreateAsync method
// Select the Inbox folder using SelectFolderAsync method to complete and fetch the list of email messages asynchronously using the ListMessagesAsync method.
static async Task ImapAsync()
{
    var tokenProvider = new TokenProvider(clientId, tenantId, redirectUri, scopes);
    var client = ImapClient.CreateAsync("outlook.office365.com", username, tokenProvider, 993).GetAwaiter().GetResult();
    await client.SelectFolderAsync(ImapFolderInfo.InBox);
    var messages = await client.ListMessagesAsync();
    Console.WriteLine("Messages :" + messages.Count);
}

// Token provider implementation
public class TokenProvider : IAsyncTokenProvider
{
    private readonly PublicClientApplicationOptions _pcaOptions;
    private readonly string[] _scopes;

    public TokenProvider(string clientId, string tenantId, string redirectUri, string[] scopes)
    {
        _pcaOptions = new PublicClientApplicationOptions
        {
            ClientId = clientId,
            TenantId = tenantId,
            RedirectUri = redirectUri
        };

        _scopes = scopes;
    }

    public async Task<OAuthToken> GetAccessTokenAsync(bool ignoreExistingToken = false, CancellationToken cancellationToken = default)
    {

        var pca = PublicClientApplicationBuilder
            .CreateWithApplicationOptions(_pcaOptions).Build();

        try
        {
            var result = await pca.AcquireTokenInteractive(_scopes)
                .WithUseEmbeddedWebView(false)
                .ExecuteAsync(cancellationToken);

            return new OAuthToken(result.AccessToken);
        }
        catch (MsalException ex)
        {
            Console.WriteLine($"Error acquiring access token: {ex}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex}");
        }

        return null;
    }

    public void Dispose()
    {

    }
}

Gestionar operaciones asíncronas

Interrumpir un método TAP

A partir de .NET Framework 4.5, puedes usar métodos asíncronos implementados según el modelo TAP. El fragmento de código a continuación muestra cómo añadir muchos mensajes usando el método basado en tareas llamado AppendMessagesAsync y luego interrumpir este proceso después de un tiempo.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET

List<MailMessage> mailMessages = new List<MailMessage>();

// create mail messages
for (int i = 0; i < 100; i++)
    mailMessages.Add(new MailMessage(senderEmail, receiverEmail, $"Message #{i}", "Text"));

using (ImapClient client = new ImapClient(host, 993, senderEmail, password, SecurityOptions.SSLImplicit))
{
    CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
    AutoResetEvent autoResetEvent = new AutoResetEvent(false);
    Exception exception = null;

    ThreadPool.QueueUserWorkItem(delegate
    {
        try
        {
            // start uploading the messages
            var task = client.AppendMessagesAsync(mailMessages, cancellationTokenSource.Token);
            AppendMessagesResult appendMessagesResult = task.GetAwaiter().GetResult();
            Console.WriteLine("All messages have been appended.");
        }
        catch (Exception e)
        {
            exception = e;
        }
        finally
        {
            autoResetEvent.Set();
        }
    });

    Thread.Sleep(5000);

    // stop uploading the messages
    cancellationTokenSource.Cancel();
    autoResetEvent.WaitOne();

    foreach (MailMessage mailMessage in mailMessages)
        mailMessage.Dispose();

    if (exception is OperationCanceledException)
        Console.WriteLine("Operation has been interrupted: " + exception.Message);
}

Cancelar operaciones asíncronas

A veces puede surgir la necesidad de detener operaciones asíncronas. Para ello, nuestra biblioteca ofrece cancelación de operaciones asíncronas mediante el uso del parámetro CancellationToken. Al invocar un método asíncrono que soporta cancelación, puedes pasar una instancia de CancellationToken como parámetro. El CancellationToken se usa para señalar y controlar la cancelación de la operación.

Para habilitar la cancelación, primero debes crear una instancia de CancellationTokenSource que proporcione el CancellationToken. Luego, pasa el CancellationToken al método asíncrono, permitiendo que verifique solicitudes de cancelación durante la ejecución.

Aquí hay un ejemplo que demuestra la cancelación usando CancellationToken:

CancellationTokenSource tokenSource = new CancellationTokenSource();
AppendMessagesResult appendMessagesResult = null;
AutoResetEvent autoResetEvent = new AutoResetEvent(false);
ThreadPool.QueueUserWorkItem(delegate(object state)
    {
        try
        {
            appendMessagesResult = imapClient.AppendMessagesAsync(mmList, tokenSource.Token).GetAwaiter().GetResult();
        }
        catch (Exception ex)
        {

        }
        finally
        {
            autoResetEvent.Set();
        }
    });

tokenSource.Cancel();
autoResetEvent.WaitOne();