Think Async [Jim's Blog]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Think Async ======

<wrap lo>Sunday June 9, 2024</wrap>

Usually, when writing asynchronous code, benefits are incremental. It can be difficult to see significant results at the micro level, unless you're willing to dig in with profiling tools. Sometimes, though, benefits are obvious. I love these, because they provide real motivation for me to take the time to write better code.

A while back, I wrote a simple application to get unread mail counts for a list of accounts. I originally wrote it in Python, but I had some issues with it not always playing nice when scheduled in [[https://github.com/brndnmtthws/conky|Conky]]. I rewrote it as a console application in C#, and got much better stability.

Originally, it was structured as follows. Information about an account is populated in a MailEntry class:

<code csharp>
public class MailEntry
{
    public MailEntry(string hostUrl, string userName, string password)
    {
        HostUrl = hostUrl;
        UserName = userName;
        Password = password;
    }

    public string? HostUrl { get; set; }
    public string? UserName { get; set; }
    public string? Password { get; set; }
}
</code>

I store my account info in appsettings, and populate a list:

<code csharp>
List<MailEntry> mailEntries = new();

// code to retrieve from appsettings goes here.
</code>

Then, I iterate through the list and use my MailHandler code to do the actual checking and reporting of unread counts:

<code csharp>
foreach (MailEntry mailEntry in mailEntries)
{
    mailHandler.CheckMail(
        mailEntry.HostUrl ?? "",
        mailEntry.UserName ?? "",
        mailEntry.Password ?? ""
    );
}
</code>

But, you'll notice that this code runs in a linear fashion.  As in:

  - Make a call to check an account.
  - Wait for that call to complete.
  - Move to the next item in the list.
  - Repeat.

I have 10 accounts that I'm checking, so this is not efficient at all. It wasn't a big deal, but it started to bother me that it was taking 10 - 15 seconds to complete on each run.  I decided to do some refactoring to support asynchronicity.  First, I changed Main():

<code csharp>
private static async Task Main(string[] args)
</code>

Then, I created a list to hold information about the state of each running task:

<code csharp>
List<Task> tasks = new();
</code>

I changed the CheckMail method in MailHandler:

<code csharp>
public async Task CheckMail(string hostUrl, string userName, string password)
</code>

I checked each method I'm calling in the IMAP library I'm using to see which ones have an asynch version, and updated them accordingly:

<code csharp>
await client.AuthenticateAsync(userName, password);

await client.Inbox.OpenAsync(FolderAccess.ReadOnly);
</code>

Back in Main(), the check loop is updated to add each async task to the list:

<code csharp>
foreach (MailEntry mailEntry in mailEntries)
{
    tasks.Add(
        mailHandler.CheckMail(
            mailEntry.HostUrl ?? "",
            mailEntry.UserName ?? "",
            mailEntry.Password ?? ""
        )
    );
}
</code>

And then I wait for all the tasks to complete before proceeding:

<code csharp>
await Task.WhenAll(tasks);
</code>

My application now runs in 2 - 4 seconds. :-) The takeaway here is that it's absolutely worth your time to look carefully at repeating logic in your code and optimize it to run asynchronously, if you can.

Full code is here: https://github.com/jfcarr/unread-mail-count