Hoe asynchrone IMAP-bewerkingen op e‑mails uit te voeren

Asynchrone bewerkingen met ImapClient

Werken met berichten kan asynchroon worden uitgevoerd met behulp van Aspose.Email ImapClient. Dit artikel laat zien hoe berichten asynchroon uit een mailbox worden opgehaald. Het artikel toont ook hoe berichten weergegeven kunnen worden door zoekcriteria te gebruiken met MailQuery. Er zal apart worden getoond hoe een bewerking met e‑mailberichten, gestart via een taakgebaseerd asynchroon patroon, onderbroken kan worden (TAP) methode.

Berichten Asynchroon Ophalen

Het onderstaande codefragment toont hoe u berichten asynchroon kunt ophalen.

Berichten asynchroon weergeven met MailQuery

De MailQuery klasse kan worden gebruikt om zoekcriteria op te geven voor het asynchroon ophalen van een opgegeven lijst berichten, zoals getoond in het onderstaande codevoorbeeld.

Berichten asynchroon verzenden

E‑mails asynchroon verzenden is zeer handig, omdat het proces de uitvoering van het programma of de thread niet blokkeert. In plaats van te wachten tot de e‑mail verzonden is voordat je andere taken uitvoert, kan het programma doorgaan terwijl de e‑mail op de achtergrond wordt verzonden.

De volgende functies helpen je bij het implementeren van asynchrone verzending in je project:

• IAsyncImapClient - Stelt toepassingen in staat om berichten te benaderen en te manipuleren met behulp van het Internet Message Access Protocol (IMAP).

• ImapClient.CreateAsync - Maakt een nieuwe instantie van de Aspose.Email.Clients.Imap.ImapClient‑klasse

Het onderstaande code‑voorbeeld demonstreert hoe je berichten op de achtergrond kunt weergeven:

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

    }
}

Asynchrone bewerkingen beheren

Een TAP-methode onderbreken

Vanaf .NET Framework 4.5 kun je asynchrone methoden gebruiken die volgens het TAP‑model zijn geïmplementeerd. De code‑snippet hieronder laat zien hoe je vele berichten kunt toevoegen met de taakgebaseerde asynchrone patroonmethode genaamd AppendMessagesAsync en onderbreek dit proces daarna een tijdje.

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

Asynchrone bewerkingen annuleren

Soms moet je asynchrone bewerkingen stoppen. Hiervoor biedt onze bibliotheek annulering van asynchrone bewerkingen via de CancellationToken‑parameter. Bij het aanroepen van een asynchrone methode die annulering ondersteunt, kun je een CancellationToken‑instantie als parameter doorgeven. Het CancellationToken wordt gebruikt om de annulering van de bewerking te signaleren en te beheersen.

Om annulering mogelijk te maken, moet je eerst een CancellationTokenSource‑instantie maken die het CancellationToken levert. Vervolgens geef je het CancellationToken door aan de asynchrone methode, zodat deze tijdens de uitvoering kan controleren op annuleringsverzoeken.

Hier is een voorbeeld dat annulering demonstreert met 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();