Come eseguire operazioni IMAP asincrone su email

Operazioni asincrone con ImapClient

Lavorare con i messaggi può essere eseguito in modo asincrono utilizzando Aspose.Email ImapClient. Questo articolo mostra il recupero di messaggi da una casella di posta in modo asincrono. Questo articolo mostra anche come elencare i messaggi fornendo criteri di ricerca usando MailQuery. Verrà mostrato separatamente come interrompere un’operazione con messaggi email avviata da un modello asincrono basato su task (TAP) metodo.

Recupera Messaggi in Modo Asincrono

Il seguente frammento di codice mostra come recuperare i messaggi in modo asincrono.

Elenca i messaggi in modo asincrono con MailQuery

Il MailQuery la classe può essere usata per specificare i criteri di ricerca per recuperare un elenco specificato di messaggi in modo asincrono, come mostrato nel seguente esempio di codice.

Invia messaggi in modo asincrono

Inviare email in modo asincrono è molto comodo, poiché il processo non blocca l’esecuzione del programma o del thread. Invece di attendere che l’email sia inviata prima di procedere con altre attività, il programma può continuare a funzionare mentre l’email viene inviata in background.

Le seguenti funzionalità ti aiuteranno a implementare l’invio asincrono nel tuo progetto:

• IAsyncImapClient - Consente alle applicazioni di accedere e manipolare i messaggi usando Internet Message Access Protocol (IMAP).

• ImapClient.CreateAsync - Crea una nuova istanza della classe Aspose.Email.Clients.Imap.ImapClient

Il campione di codice riportato di seguito dimostra come elencare i messaggi in background:

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

    }
}

Gestione delle operazioni asincrone

Interrompi un metodo TAP

A partire da .NET Framework 4.5, è possibile utilizzare metodi asincroni implementati secondo il modello TAP. Il frammento di codice seguente mostra come aggiungere molti messaggi usando il metodo basato sul modello asincrono basato su task chiamato AppendMessagesAsync e poi interrompere questo processo dopo un po'.

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

Annulla operazioni asincrone

A volte può rendersi necessario interrompere operazioni asincrone. A tal fine la nostra libreria offre la cancellazione delle operazioni asincrone tramite l’uso del parametro CancellationToken. Quando si invoca un metodo asincrono che supporta la cancellazione, è possibile passare un’istanza di CancellationToken come parametro. Il CancellationToken è usato per segnalare e controllare la cancellazione dell’operazione.

Per abilitare la cancellazione, è necessario prima creare un’istanza di CancellationTokenSource che fornisce il CancellationToken. Quindi, passa il CancellationToken al metodo asincrono, consentendogli di verificare le richieste di cancellazione durante l’esecuzione.

Ecco un esempio che dimostra la cancellazione 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();