Comment exécuter des opérations IMAP asynchrones sur les e‑mails

Opérations asynchrones avec ImapClient

Travailler avec les messages peut être effectué de façon asynchrone en utilisant Aspose.Email ImapClient. Cet article montre la récupération asynchrone de messages depuis une boîte aux lettres. Il montre également comment lister les messages en fournissant des critères de recherche à l’aide de MailQuery. Il sera montré séparément comment interrompre une opération avec des messages e‑mail démarrés par un modèle asynchrone basé sur les tâches (TAP) méthode.

Récupérer des messages de manière asynchrone

Le fragment de code suivant vous montre comment récupérer les messages de manière asynchrone.

Lister les messages de façon asynchrone avec MailQuery

Le MailQuery La classe peut être utilisée pour spécifier les critères de recherche afin de récupérer une liste spécifiée de messages de manière asynchrone, comme le montre l’exemple de code suivant.

Envoyer les messages de façon asynchrone

L’envoi d’e‑mails de façon asynchrone est très pratique, car le processus ne bloque pas l’exécution du programme ou du thread. Au lieu d’attendre que l’e‑mail soit envoyé avant de poursuivre d’autres tâches, le programme peut continuer à fonctionner pendant que l’e‑mail est envoyé en arrière‑plan.

Les fonctionnalités suivantes vous aideront à implémenter l’envoi asynchrone dans votre projet :

• IAsyncImapClient - Permet aux applications d’accéder aux messages et de les manipuler en utilisant le protocole IMAP (Internet Message Access Protocol).

• ImapClient.CreateAsync - Crée une nouvelle instance de la classe Aspose.Email.Clients.Imap.ImapClient

L’exemple de code ci-dessous montre comment lister les messages en arrière‑plan :

// 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()
    {

    }
}

Gestion des opérations asynchrones

Interrompre une méthode TAP

À partir du .NET Framework 4.5, vous pouvez utiliser des méthodes asynchrones implémentées selon le modèle TAP. Le fragment de code ci-dessous montre comment ajouter de nombreux messages en utilisant la méthode basée sur le modèle asynchrone à tâches nommée AppendMessagesAsync et interrompre ensuite ce processus après un certain temps.

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

Annuler les opérations asynchrones

Parfois, il peut être nécessaire d’arrêter des opérations asynchrones. À cet effet, notre bibliothèque propose l’annulation des opérations asynchrones via le paramètre CancellationToken. Lors de l’appel d’une méthode asynchrone qui prend en charge l’annulation, vous pouvez transmettre une instance de CancellationToken en paramètre. Le CancellationToken sert à signaler et contrôler l’annulation de l’opération.

Pour activer l’annulation, vous devez d’abord créer une instance de CancellationTokenSource qui fournit le CancellationToken. Ensuite, transmettez le CancellationToken à la méthode asynchrone, ce qui lui permet de vérifier les demandes d’annulation pendant l’exécution.

Voici un exemple qui démontre l’annulation à l’aide de 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();