Custom message pumping with c# async calls

Question

I'm creating my own UI handling logic that runs on a single thread. Basically, what I'm doing is

void HandlerMain()
{
    while (true)
    {
        Task[] events = PumpEvents();
        Task.WaitAll(events);
    }
}

where one example task that PumpEvents() returns is

async Task ButtonClick()
{
    var httpClient = new HttpClient();
    string s = await httpClient.GetStringAsync("http://microsoft.com");
    Console.WriteLine(s);
}

The problem of my code is, if one of events takes a long time, it's stuck at Task.WaitAll(), so it can't pump new events making the UI not responsive. Is there any other method than WaitAll() something like

Task[] remainingEvents = PumpEvents();
while (true)
{
    remainingEvents = WaitUntilEveryTasksAwait(remainingEvents);
    remainingEvents.Append(PumpEvents());
}

Maybe I'm on wrong track. I'd appreciate your advice!

*" if one of events takes a long time, it's stuck at Task.WaitAll(), so it can't pump new events making the UI not responsive"*, yes, and the exact same thing happens with the normal UI thread. When you have a long running processes on your UI thread your UI locks up because it can't pump messages. What where your expectations to happen? — Scott Chamberlain, Apr 27 '14 at 08:07
@ScottChamberlain No. The built-in UI processor, say WPF, correctly handles async events so whenever the async events do "await", it skips the current context and handles the next events. I want to duplicate this behavior. — D. Fisher, Apr 27 '14 at 09:16
`I'm creating my own UI handling logic...` Why not use a WPF or WinForms message loop, as appropriate? — Stephen Cleary, Apr 27 '14 at 20:24

score 2 · Accepted Answer · answered Apr 27 '14 at 17:49

@ScottChamberlain No. The built-in UI processor, say WPF, correctly handles async events so whenever the async events do "await", it skips the current context and handles the next events. I want to duplicate this behavior

Based on your comment to me I now understand what your problem is. You need more logic than your simple while(true) loop to be able to process the await messages. The entire system is built up upon the class SynchronizationContext, what you will need to do is derive your own class from SynchronizationContext and override it's methods to queue up your work to be done inside your while loop.

See this article from Stephen Cleary to give you more information on how a Synchronization Context works and posibly some ideas on where to start writing your own.

Daniel Mann · Answer 2 · 2014-04-27T05:11:58.163

If I'm understanding, you don't actually need to wait until those tasks are complete to continue. Just remove the call to Task.WaitAll.

For the record, Task.WaitAll is synchronous -- it blocks. You're better off using Task.WhenAll, which returns a task that completes when all of the provided tasks are complete. That lets you await it just like you'd await any of the individual tasks. Just doing that would solve the problem and keep the UI responsive.

E.g.:

async Task HandlerMain()
{
    while (true)
    {
        Task[] events = PumpEvents();
        await Task.WhenAll(events);
    }
}

Of course, in this case, depending on what was calling HandlerMain, you'd still have the problem where PumpEvents was hung up waiting on the long-running task.

This starts to lead down the path of questions like, "Why are you writing your own custom UI message pump when WPF and WinForms have that problem already solved?"

If I remove the call to `WaitAll()`, how can I proceed to the task of the second events in `events` when the first task awaits? In addition, I still want to pump events whenever all tasks await. (Btw, `HandlerMain()` is the entry point of a thread, so it cannot be async.) — D. Fisher, Apr 27 '14 at 05:38

Custom message pumping with c# async calls

2 Answers2