Wie man asynchrone IMAP‑Operationen für E‑Mails ausführt

Asynchrone Operationen mit ImapClient

Die Arbeit mit Nachrichten kann asynchron durchgeführt werden, indem Aspose.Email verwendet wird ImapClient. Dieser Artikel zeigt das asynchrone Abrufen von Nachrichten aus einem Postfach. Der Artikel zeigt außerdem, wie man Nachrichten durch Angabe von Suchkriterien auflistet, indem man MailQuery. Es wird separat gezeigt, wie man einen Vorgang mit E‑Mail‑Nachrichten, die durch ein task‑basiertes asynchrones Muster gestartet wurden, unterbricht (TAP)‑Methode.

Nachrichten asynchron abrufen

Das folgende Code‑Snippet zeigt, wie man Nachrichten asynchron abruft.

Nachrichten asynchron mit MailQuery auflisten

Die MailQuery Klasse kann verwendet werden, um Suchkriterien für das asynchrone Abrufen einer bestimmten Nachrichtenliste festzulegen, wie im folgenden Codebeispiel gezeigt.

Nachrichten asynchron senden

Das asynchrone Senden von E‑Mails ist sehr praktisch, da der Vorgang die Ausführung des Programms oder Threads nicht blockiert. Anstatt auf das Senden der E‑Mail zu warten, bevor weitere Aufgaben ausgeführt werden, kann das Programm weiterlaufen, während die E‑Mail im Hintergrund gesendet wird.

Die folgenden Funktionen unterstützen Sie beim Implementieren von asynchronem Senden in Ihrem Projekt:

• IAsyncImapClient - Ermöglicht Anwendungen den Zugriff auf und die Manipulation von Nachrichten mittels des Internet Message Access Protocol (IMAP).

• ImapClient.CreateAsync - Erstellt eine neue Instanz der Klasse Aspose.Email.Clients.Imap.ImapClient

Das unten gezeigte Codebeispiel demonstriert, wie man Nachrichten im Hintergrund auflisten kann:

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

    }
}

Verwalten asynchroner Vorgänge

Eine TAP‑Methode unterbrechen

Ab .NET Framework 4.5 können Sie asynchrone Methoden gemäß dem TAP‑Modell verwenden. Das untenstehende Code‑Snippet zeigt, wie man viele Nachrichten mittels der task‑basierten asynchronen Muster‑Methode namens AppendMessagesAsync und dann unterbrechen Sie diesen Vorgang nach einer Weile.

// 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 Vorgänge abbrechen

Manchmal müssen Sie möglicherweise asynchrone Vorgänge stoppen. Zu diesem Zweck bietet unsere Bibliothek die Möglichkeit, asynchrone Vorgänge über den CancellationToken‑Parameter abzubrechen. Beim Aufruf einer asynchronen Methode, die den Abbruch unterstützt, können Sie eine CancellationToken‑Instanz als Parameter übergeben. Der CancellationToken wird verwendet, um den Abbruch des Vorgangs zu signalisieren und zu steuern.

Um Abbruch zu ermöglichen, müssen Sie zunächst eine Instanz von CancellationTokenSource erstellen, die das CancellationToken liefert. Anschließend übergeben Sie das CancellationToken an die asynchrone Methode, damit sie während der Ausführung nach Abbruchanforderungen prüfen kann.

Hier ist ein Beispiel, das die Abbruch‑Funktion mittels CancellationToken demonstriert:

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();