Hur man utför asynkrona IMAP‑operationer på e‑post

Asynkrona operationer med ImapClient

Arbete med meddelanden kan utföras asynkront med hjälp av Aspose.Email ImapClient. Denna artikel visar hur man hämtar meddelanden från en brevlåda asynkront. Artikeln visar också hur man listar meddelanden genom att ange sökkriterier med MailQuery. Det kommer att visas separat hur man avbryter en operation med e‑postmeddelanden som startats av ett task‑baserat asynkront mönster (TAP) metod.

Hämta meddelanden asynkront

Följande kodsnutt visar hur man hämtar meddelanden asynkront.

Lista meddelanden asynkront med MailQuery

Den MailQuery klass kan användas för att specificera sökkriterier för att hämta en angiven lista med meddelanden asynkront, som visas i följande kodexempel.

Skicka meddelanden asynkront

Att skicka e‑post asynkront är mycket bekvämt, eftersom processen inte blockerar programmets eller trådens körning. Istället för att vänta på att e‑posten ska skickas innan du fortsätter med andra uppgifter, kan programmet fortsätta köra medan e‑posten skickas i bakgrunden.

Följande funktioner hjälper dig att implementera asynkron sändning i ditt projekt:

• IAsyncImapClient - Tillåter applikationer att komma åt och manipulera meddelanden genom att använda Internet Message Access Protocol (IMAP).

• ImapClient.CreateAsync - Skapar en ny instans av klassen Aspose.Email.Clients.Imap.ImapClient

Kodexemplet nedan demonstrerar hur man listar meddelanden i bakgrunden:

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

    }
}

Hantera asynkrona operationer

Avbryt en TAP‑metod

Från och med .NET Framework 4.5 kan du använda asynkrona metoder implementerade enligt TAP‑modellen. Kodsnutten nedan visar hur man lägger till många meddelanden med den task‑baserade asynkrona mönster‑metoden som heter AppendMessagesAsync och avbryt sedan processen efter ett tag.

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

Avbryt asynkrona operationer

Ibland kan du behöva stoppa asynkrona operationer. För detta ändamål erbjuder vårt bibliotek avbrytning av asynkrona operationer via CancellationToken‑parametern. När du anropar en asynkron metod som stödjer avbrytning kan du skicka en CancellationToken‑instans som parameter. CancellationToken används för att signalera och styra avbrytning av operationen.

För att möjliggöra avbrytning måste du först skapa en instance av CancellationTokenSource som tillhandahåller CancellationToken. Sedan skickar du CancellationToken till den asynkrona metoden, så att den kan kontrollera avbrytningsbegäran under körning.

Här är ett exempel som demonstrerar avbrytning med 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();