Jak wykonywać asynchroniczne operacje IMAP na e‑mailach

Asynchroniczne operacje z ImapClient

Praca z wiadomościami może być wykonywana asynchronicznie przy użyciu Aspose.Email ImapClient. Ten artykuł pokazuje asynchroniczne pobieranie wiadomości ze skrzynki pocztowej. Pokazuje również, jak wyświetlać wiadomości, podając kryteria wyszukiwania przy użyciu MailQuery. Pokażemy oddzielnie, jak przerwać operację z wiadomościami e‑mail rozpoczętą w oparciu o wzorzec asynchroniczny oparty na zadaniach (TAP) metoda.

Pobieranie wiadomości asynchronicznie

Poniższy fragment kodu pokazuje, jak pobrać wiadomości asynchronicznie.

Listuj wiadomości asynchronicznie przy użyciu MailQuery

Ten MailQuery klasa może być użyta do określenia kryteriów wyszukiwania w celu asynchronicznego pobrania określonej listy wiadomości, jak pokazano w poniższym przykładzie kodu.

Wysyłaj wiadomości asynchronicznie

Wysyłanie e‑maili asynchronicznie jest bardzo wygodne, ponieważ proces nie blokuje wykonywania programu ani wątku. Zamiast czekać na wysłanie e‑maila przed kontynuacją innych zadań, program może kontynuować działanie, podczas gdy e‑mail jest wysyłany w tle.

Następujące funkcje pomogą Ci wdrożyć asynchroniczne wysyłanie w Twoim projekcie:

• IAsyncImapClient - Umożliwia aplikacjom dostęp i manipulację wiadomościami przy użyciu protokołu Internet Message Access Protocol (IMAP).

• ImapClient.CreateAsync - Tworzy nową instancję klasy Aspose.Email.Clients.Imap.ImapClient

Poniższy przykładowy kod demonstruje, jak wyświetlać wiadomości w tle:

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

    }
}

Zarządzanie operacjami asynchronicznymi

Przerwij metodę TAP

Od .NET Framework 4.5 możesz używać metod asynchronicznych zaimplementowanych zgodnie z modelem TAP. Poniższy fragment kodu pokazuje, jak dołączać wiele wiadomości przy użyciu metody opartej na wzorcu asynchronicznym opartym na zadaniach, nazwanego AppendMessagesAsync a następnie przerwać ten proces po chwili.

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

Anuluj operacje asynchroniczne

Czasami może zajść potrzeba zatrzymania operacji asynchronicznych. W tym celu nasza biblioteka oferuje anulowanie operacji asynchronicznych przy użyciu parametru CancellationToken. Wywołując metodę asynchroniczną obsługującą anulowanie, możesz przekazać instancję CancellationToken jako parametr. CancellationToken służy do sygnalizowania i kontrolowania anulowania operacji.

Aby włączyć anulowanie, najpierw musisz utworzyć instancję CancellationTokenSource, która dostarcza CancellationToken. Następnie przekaż CancellationToken do metody asynchronicznej, umożliwiając jej sprawdzanie żądań anulowania podczas wykonywania.

Oto przykład demonstrujący anulowanie przy użyciu 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();