Question

I have an application that contains a bunch of sections, each containing data that takes significant time to calculate. There are a few approaches I can see to this:

1. Simple solution 1: Calculate the data in all the sections on application startup. This means application startup will be slow.

2. Simple solution 2: Calculate the data in each section as the user loads it. This means that loading each section will be slow (which is bad, because each section has to do significant rendering calculation already, so they’re already a bit slow.

3. Because performance is critical for this application, neither of these solutions is ideal. So this brings me to a less-simple solution: on app startup, start calculating section data on a background thread. The problem with this solution is that I don’t have a good way of predicting which section the user will load first. So if they load the last section to load on the background thread, they’ll end up waiting longer than if I had just gone with solution 2.

4. So this brings me to solution: on app startup, start calculating section data on a background thread, but when the user loads a section, pause the background thread and start the calculation for the section the user requested. Unless the calculation is already started, in which case you let it finish.

I’m not sure how to implement solution 4. I think the simplest solution is probably to use a priority queue and just up the priority of a task when it’s loaded, but I’m not sure how to implement this in C#. Is this a reasonable approach? What good libraries are there for priority queues in C#?

Answer 1

So we’ll start with an array (or some other data structure if you want) of Task<Section> objects.

private Task<Section>[] sections = new Task<Section>[5];

You should ensure that the collection is created and actually define the tasks at the very start of your application (not in the background).

for (int i = 0; i < sections.Length; i++)
{
    int sectionNumber = i; //copy for closure
    Task<Section> next = new Task<Section>(() => CreateSection(sectionNumber));
    //note the task isn't started.
    sections[i] = next;
}

Then you can start the background task to actually process the tasks one at a time:

Task.Run(() =>
{
    for (int i = 0; i < sections.Length; i++)
    {
        EnsureStarted(sections[i]);
        sections[i].Wait();
    }
});

You could use a Parallel.For if you want to have several threads working on items.

That method uses this helper method:

public void EnsureStarted(Task task)
{
    if (task.Status == TaskStatus.Created)
    {
        task.Start();
    }
}

Then to actually get a finished section (starting it if needed):

public Section GetFinishedSection(int sectionNumber)
{
    EnsureStarted(sections[sectionNumber]);
    return sections[sectionNumber].Result;
}

If you need a non-blocking version of that (possibly to await it) you can use this:

public Task<Section> EnsureSectionComplete(int sectionNumber)
{
    EnsureStarted(sections[sectionNumber]);
    return sections[sectionNumber];
}