valerio.net

EDIT: Oops, sorry for the typo in the title. I meant “generic delegates”, not “anonymous delegates”.

Last week I wrote a post about using a generic wrapper around the BackgroundWorker class to execute long-running tasks on a different thread. This makes for a more responsive UI since the UI thread is free to process the Windows message pump.

The cool thing about using the BackgroundWorker (and also the BackgroundWorkerHelper) is that no matter how many times the user presses the button to start a long-running process, a new worker thread is created, executed, and marshalled back to the UI thread. This means that if you press a button that, say, runs a 5-second process at t=0, 1, 2, and 3 seconds, then you’ll see a result at t=5, 6, 7, and 8 seconds.

Most of the time this is the desired response. Recently I just ran into a particular scenario where I didn’t want the second long-running process to start until the first finished. In my case, I had a button that the user could press to print the current page. If they pressed the button again before the page had finished printing, then an error would be thrown. What I really need is a BackgroundWorker that queues up each new call to it and executes the next call only when the previous call has completed.

We can combine the same anonymous wrapper approach with a Queue to achieve this exact functionality! Here’s the code for the QueuedBackgroundWorker:

public static class QueuedBackgroundWorker
    {
        public static void QueueWorkItem(
            Queue> queue,
            Tin inputArgument,
            Func, Tout> doWork,
            Action> workerCompleted)
        {
            if (queue == null) throw new ArgumentNullException("queue");

            BackgroundWorker bw = new BackgroundWorker();
            bw.WorkerReportsProgress = false;
            bw.WorkerSupportsCancellation = false;
            bw.DoWork += (sender, args) =>
            {
                if (doWork != null)
                {
                    args.Result = doWork(new DoWorkArgument((Tin)args.Argument));
                }
            };
            bw.RunWorkerCompleted += (sender, args) =>
            {
                if (workerCompleted != null)
                {
                    workerCompleted(new WorkerResult((Tout)args.Result, args.Error));
                }
                queue.Dequeue();
                if (queue.Count > 0)
                {
                    QueueItem nextItem = queue.Peek();
                    nextItem.BackgroundWorker.RunWorkerAsync(nextItem.Argument);
                }
            };

            queue.Enqueue(new QueueItem(bw, inputArgument));
            if (queue.Count == 1)
            {
                QueueItem nextItem = queue.Peek();
                nextItem.BackgroundWorker.RunWorkerAsync(nextItem.Argument);
            }
        }

Along with these generic helper classes:

    public class DoWorkArgument
    {
        public DoWorkArgument(T argument)
        {
            this.Argument = argument;
        }
        public T Argument { get; private set; }
    }

    public class WorkerResult
    {
        public WorkerResult(T result, Exception error)
        {
            this.Result = result;
            this.Error = error;
        }

        public T Result { get; private set; }
        public Exception Error { get; private set; }
    }

    public class QueueItem
    {
        public QueueItem(BackgroundWorker backgroundWorker, Tin argument)
        {
            this.BackgroundWorker = backgroundWorker;
            this.Argument = argument;
        }

        public Tin Argument { get; private set; }
        public BackgroundWorker BackgroundWorker { get; private set; }
    }

To test this, I created a quick-n-dirty WinForms application with a button and a textbox. When the user preses the button, a new item is added to the QueuedBackgroundWorker’s Queue. When the long-running (in this case 1 second) process completes, it appends a message to the textbox. For example:

        private Queue> m_Queue = new Queue>();
        private int m_Count = 0;

        private void btnStart_Click(object sender, EventArgs e)
        {
            QueuedBackgroundWorker.QueueWorkItem(
                m_Queue,
                m_Count++,
                args =>
                {
                    string now = DateTime.Now.ToLongTimeString();
                    int count = args.Argument;
                    Thread.Sleep(1000);
                    string message = String.Format("Inside background thread: Time={0} Count=[{1}]", now, count);
                    return new { Count = count, Message = message };
                },
                args =>
                {
                    string now = DateTime.Now.ToLongTimeString();
                    int count = args.Result.Count;
                    string message = args.Result.Message;
                    string line = String.Format("Received Result: Time={0} Count={1} Message=[{2}]{3}",
                        now, count, message, Environment.NewLine);
                    txtOutput.AppendText(line);
                });
        }

After testing it out, it behaves exactly as expected I can now use this in my application to queue up things to print. Each item will only begin printing after the previous one completes. Here’s a screenshot:

Essentially what we’ve done here is create a collection (queue) of input objects for the DoWork method of the BackgroundWorker. The really cool part is that the generic delegate for this method is type-safe and can be used with anonymous types (as seen in the above example, just for fun).

I’m really digging all of these new .NET 3.0 features

Hope someone finds that useful!

You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.