Question

Without using extra threads I would simply like to display a “Loading” label or something similar to the user when a large amount of data is being read or written. If I however attempt to modify any UI elements before calling the IO method, the application freezes for a while and then displays the “Loading” message after all the work is already done. This obviously doesn’t help. How can I ensure that any UI changes are applied and visible before calling the IO method?

        DataSet ds = STT_Import.ImportExcelToDataSet(filePath);

        bool result = false;

        if (ds != null)
        {
            int cellCount = ds.GetTotalCellCount();

            if (Popup.ShowMessage(string.Format("Your file contains {0} cells. Inserting data will take approximately {1} seconds. Do you want to continue?",
                cellCount, CalculateTime(cellCount)), "Confirm", MessageType.Confirm) == MessageBoxResult.Yes)
            {
                // Tell user the application is working:
                StatusLabel.Content = "Writing to database...";

                // Do actual work after user has been notified:
                result = DB.StoreItems(_currentType, ds);
            }
        }

I tried looking for answers but couldn’t find anything that answered my specific question, so I’m sorry if the question has been asked before.

Answer 1

When working with WPF, you can use the Dispatcher to queue commands on the UI thread at different DispatcherPriorities

This will allow you to queue your long-running process on the UI thread after everything in the DispatcherPriority.Render or DispatcherPriority.Loaded queues have occurred.

For example, your code may look like this:

// Tell user the application is working:
StatusLabel.Content = "Writing to database...";

// Do actual work after user has been notified:
Dispatcher.BeginInvoke(DispatcherPriority.Input,
    new Action(delegate() { 
        var result = DB.StoreItems(_currentType, ds);     // Do Work
        if (result)
            StatusLabel.Content = "Finished";
        else
            StatusLabel.Content = "An error has occured";
     }));

It should be noted though that its usually considered bad design to lock up an application while something is running.

A better solution would be to run the long-running process on a background thread, and simply disable your application form while it runs. There are many ways of doing this, but my personal preference is using the Task Parallel Library for it’s simplicity.

As an example, your code to use a background thread would look something like this:

using System.Threading.Tasks;

...

// Tell user the application is working:
StatusLabel.Content = "Writing to database...";
MyWindow.IsEnabled = False;

// Do actual work after user has been notified:
Task.Factory.StartNew(() => DB.StoreItems(_currentType, ds))
    // This runs after background thread is finished executing
    .ContinueWith((e) =>
    {
        var isSuccessful = e.Result;

        if (isSuccessful)
            StatusLabel.Content = "Finished";
        else
            StatusLabel.Content = "An error has occured";

        MyWindow.Enabled = true;
    });