Database remote events and asynchronous programming

Question

I have a synchronous method that calls a method which collates a bunch of data on a custom object and stores it on a table entry on a Firebird database, located on a server.

On the server, a monitoring process keeps watching the first table for new entries using a database event (a table trigger raises an event which is captured by the monitor). When this event is raised, that data is sent to a third-party black-box service to be processed with the use of a proprietary library, that takes between near-naught and 1 minute to reply.

The third-party service replies with some data which is entered on a second table on the database. This second table has another trigger that the client's program monitors. The client's program must either wait until the third-party replies some data, or it times out (the same 1 minute).

I'm currently delving into the world of database events and I've reached an impasse:

Currently I have a key press that runs a synchronous method, which according to an application setting either runs another synchronous method, which runs flawlessly, or another method that inserts an entry on a Firebird database. This database is monitored by another process, which reads that entry, do some stuff, and inserts the new data on another table.

Back on the main program, what I currently have is the method has an event handler which is triggered when the new data is inserted. However, as it is an event, the rest of the method runs its course, ending prematurely, before the event handler has the chance to read the new data.

In pseudo code:

MainWindow_KeyDown(object sender, EventArgs e)
{
    if (e.Key == X)
    {
        MakeADecision()
    }
}

MakeADecision()
{
    if (Properties.Settings.Default.MySetting) Console.Write(DoLocalStuff());
    else Console.Write(DoRemoteStuff());
}

string DoRemoteStuff()
{
    using (OldDataTableAdapter)
    using (NewDataTableAdapter)
    {
        OldDataTableAdapter.Insert(OldData);
        var revent = new FBRemoteEvent(MyConnectionString);
        revent.RemoteEventCounts += (sender, e) =>
        {
            NewDataTableAdapter.Fill(NewDataDataTable);
            NewData = NewDataDataTable[0].MYCOLUMN;
        };
        revent.QueueEvents("MY_FB_EVENT");
    }
    return NewData;
}

As you can see, the issue here is that DoRemoteStuff reaches its return before the event can be triggered. I tried turning DoRemoteStuff() into an async method, but I don't know how to use events with async methods. Can anyone please help me with this? Any tips or hints on how to work with async methods?

Answer 1

A possible solution would be to use a TaskCompletionSource so you can convert your method to an async method. This is based on Is it possible to await an event instead of another async method?.

MakeADecision()
{
    if (Properties.Settings.Default.MySetting)
    { 
        Console.Write(DoLocalStuff());
    }
    else
    {
        // Consider making MakeADecision async as well
        NewData = DoRemoteStuff().Result;
        Console.Write(NewData);
    }
}

async Task<string> DoRemoteStuff()
{
    Task<string> task;
    using (OldDataTableAdapter)
    {
        OldDataTableAdapter.Insert(OldData);
        task = WaitForEvent(MyConnectionString);
    }
    return await task;
}

private async Task<string> WaitForEvent(string connectionString)
{
    var taskCompletionSource = new TaskCompletionSource<string>();
    var revent = new FbRemoteEvent(connectionString);
    revent.RemoteEventCounts += (sender, e) =>
    {
        using (NewDataTableAdapter)
        {
            NewDataTableAdapter.Fill(NewDataDataTable);
            string newData = NewDataDataTable[0].MYCOLUMN;
            taskCompletionSource.SetResult(newData);
        }
        sender.Dispose();
    };
    revent.QueueEvents("MY_FB_EVENT");

    return await taskCompletionSource.Task;
}

Some things to point out:

• You need to explicitly dispose the event to avoid a memory leak
• The using for NewDataTableAdapter belongs within the event handler
• The MakeADecision method seems like a candidate to be made async as well

A word of warning, my C# is a bit rusty (and I have never done much with async), so I'm not sure if this is the idiomatic way of doing it. I also did not test the code as written above (I wrote and tested a simpler version, but I may have introduced bugs while transforming your code to a similar solution).

This solution may also have the possibility of a race condition between inserting the new data triggering the event and registering for the event (unless the Dispose at the end of the using block is what commits the data), consider moving the WaitForEvent before inserting. Also consider the possibility of receiving the event from an update done for/by another change.