Como Executar Operações IMAP Assíncronas em E‑mails

Operações Assíncronas com ImapClient

Trabalhar com mensagens pode ser feito de forma assíncrona usando o Aspose.Email ImapClient. Este artigo mostra como recuperar mensagens de uma caixa de correio de forma assíncrona. Este artigo também mostra como listar mensagens fornecendo critérios de pesquisa usando MailQuery. Será mostrado separadamente como interromper uma operação com mensagens de e‑mail iniciada por um padrão assíncrono baseado em tarefas (TAP) método.

Recuperar Mensagens de forma Assíncrona

O trecho de código a seguir mostra como recuperar mensagens de forma assíncrona.

Listar Mensagens Assincronamente com MailQuery

O MailQuery classe pode ser usada para especificar critérios de pesquisa para recuperar uma lista especificada de mensagens de forma assíncrona, como mostrado no exemplo de código a seguir.

Enviar Mensagens Assincronamente

Enviar e‑mails de forma assíncrona é muito conveniente, pois o processo não bloqueia a execução do programa ou da thread. Em vez de aguardar o envio do e‑mail antes de prosseguir com outras tarefas, o programa pode continuar rodando enquanto o e‑mail é enviado em segundo plano.

Os recursos a seguir ajudarão a implementar o envio assíncrono em seu projeto:

• IAsyncImapClient - Permite que aplicações acessem e manipulem mensagens usando o Internet Message Access Protocol (IMAP).

• ImapClient.CreateAsync - Cria uma nova instância da classe Aspose.Email.Clients.Imap.ImapClient

O exemplo de código abaixo demonstra como listar mensagens em 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()
    {

    }
}

Gerenciando Operações Assíncronas

Interromper um Método TAP

A partir do .NET Framework 4.5, você pode usar métodos assíncronos implementados de acordo com o modelo TAP. O trecho de código abaixo mostra como anexar várias mensagens usando o método baseado em tarefas chamado AppendMessagesAsync e então interromper este processo depois de um tempo.

// 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 Operações Assíncronas

Às vezes você pode precisar interromper operações assíncronas. Para isso, nossa biblioteca oferece cancelamento de operações assíncronas através do uso do parâmetro CancellationToken. Ao invocar um método assíncrono que suporta cancelamento, você pode passar uma instância de CancellationToken como parâmetro. O CancellationToken é usado para sinalizar e controlar o cancelamento da operação.

Para habilitar o cancelamento, primeiro você precisa criar uma instância de CancellationTokenSource que fornece o CancellationToken. Em seguida, passe o CancellationToken para o método assíncrono, permitindo que ele verifique solicitações de cancelamento durante a execução.

Aqui está um exemplo que demonstra cancelamento 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();