כיצד לבצע פעולות IMAP אסינכרוניות על מיילים

פעולות אסינכרוניות עם ImapClient

עבודה עם הודעות ניתן לבצע אסינכרונית באמצעות Aspose.Email ImapClient. מאמר זה מציג שליפת הודעות מתיבת דואר באופן אסינכרוני. מאמר זה גם מציג כיצד לרשום הודעות על‑ידי הצגת קריטריוני חיפוש באמצעות MailQuery. יוצג בנפרד כיצד להפריע לפעולה עם הודעות מייל שהחלה באמצעות תבנית אסינכרונית מבוססת משימות (TAP) שיטה.

איחזור הודעות באופן אסינכרוני

הקטע הקוד הבא מראה כיצד לאחזר הודעות באופן אסינכרוני.

רשימת הודעות בצורה אסינכרונית עם MailQuery

ה MailQuery ניתן להשתמש במחלקה כדי לציין קריטריוני חיפוש לאחזור רשימה מסוימת של הודעות באופן אסינכרוני כפי שמודגם בדוגמת הקוד הבאה.

שלח הודעות אסינכרוניות

שליחת אימיילים באופן אסינכרוני נוחה מאוד, שכן התהליך אינו חוסם את ריצת התוכנית או חוט הביצוע. במקום להמתין לשליחת האימייל לפני המשך המשימות, התוכנית יכולה להמשיך לרוץ בזמן שהאימייל נשלח ברקע.

התכונות הבאות יעזרו לך ליישם שליחה אסינכרונית בפרויקט שלך:

IAsyncImapClient - מאפשר ליישומים לגשת ולהתעסק עם הודעות באמצעות פרוטוקול גישה להודעות אינטרנט (IMAP).
ImapClient.CreateAsync - יוצר מופע חדש של מחלקת Aspose.Email.Clients.Imap.ImapClient

דוגמת הקוד המוצגת למטה מדגימה כיצד לרשום הודעות ברקע:

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

    }
}

ניהול פעולות אסינכרוניות

הפסקת שיטת TAP

החל מ‑.NET Framework 4.5, ניתן להשתמש במתודות אסינכרוניות המיושמות לפי מודל TAP. קטע הקוד למטה מציג כיצד לצרף מספר רב של הודעות באמצעות מתודת תבנית אסינכרונית מבוססת משימות בשם AppendMessagesAsync ואז להפריע לתהליך זה אחרי זמן מה.

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

ביטול פעולות אסינכרוניות

לפעמים תיתכן צורך לעצור פעולות אסינכרוניות. למטרה זו הספרייה שלנו מציעה ביטול של פעולות אסינכרוניות באמצעות פרמטר CancellationToken. כאשר קוראים למתודה אסינכרונית התומכת בביטול, ניתן להעביר מופע של CancellationToken כפרמטר. ה‑CancellationToken משמש לסימון ושליטה בביטול הפעולה.

כדי להפעיל ביטול, יש תחילה ליצור מופע של CancellationTokenSource המספק את ה‑CancellationToken. לאחר מכן, העבירו את ה‑CancellationToken למתודה האסינכרונית, המאפשרת לבדוק בקשות ביטול במהלך הביצוע.

הנה דוגמה שממחישה ביטול באמצעות 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();

**ניהול תיקיות בשרת IMAP** איך לאפשר רישום פעילות IMAP

**כיצד לבצע פעולות IMAP אסינכרוניות על מיילים**