Tag Archives: delegates

Queue multiple GUI updates into a single update event (C# .Net)

I’m writing a simple utility that involves scanning a hard disk and updating a display with the latest status. There are potentially many, many, many, many, MANY changes that happen to the display in very quick succession and sending an update event which triggers a screen refresh for every single state change would be an enormous bottleneck.

I implemented a simple queueing scenario where all the updated objects are queued for up to 200ms before being batched into a single event. The GUI can then update the display for every changed object all at once.

First, the queue:

        private DateTime lastUpdateSent = DateTime.MinValue;
        
        //queue updated folders to limit the number of screen updates
        List<FolderObject> updatedFoldersQueue = new List<FolderObject>();

A simple list. Then I have a function which is called to handle the actual event generation:

private void FireUpdate(FolderObject folder)
        {
            if (this.OnFolderUpdated!=null)
            {
                try
                {
                    if (!folder.Dirty)
                    {
                        folder.Dirty = true;
                        updatedFoldersQueue.Add(folder);
                    }
                    TimeSpan diff = DateTime.Now - lastUpdateSent;

                    if (diff.TotalMilliseconds > 200){
                        FolderUpdatedEventArgs args = 
new FolderUpdatedEventArgs(updatedFoldersQueue);
                        int numFolders = updatedFoldersQueue.Count;
                        //reinitialize queue
                        updatedFoldersQueue = 
new List<FolderObject>(numFolders);
                        OnFolderUpdated(this, args);
                        Thread.Sleep(0);

                        lastUpdateSent = DateTime.Now;
                    }
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Trace.WriteLine(ex.Message);
                    System.Diagnostics.Trace.WriteLine(ex.StackTrace);
                }
            }
        }

The folder.Dirty flag merely prevents a folder from being queued twice. The TimeSpan diff is the important bit. By checking the time difference between now and the last updated time, we can ensure that updates only get sent as often as the display–and our eyes–can handle them. The Thread.Sleep(0) ensures that the GUI thread gets a chance to draw–this is supposed to be interactive, after all.