WPF Progress Bars

Note: I've posted an updated, even easier to use version of this code here:

WPF Progress Bars Revisited

Implementing a progress bar display for long-running tasks is a commonly occurring task. WPF has a simple ProgressBar control which works as you would expect. It has a floating point Value property that is used to display progress within a range (set using the Minimum and Maximum properties). Here is some XAML to implement a progress dialog:

<Window x:Class="MyNamespace.ProgressDialog"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   Title="Progress Dialog" Width="300" SizeToContent="Height">
   <Grid>
       <StackPanel Margin="10">
           <ProgressBar Name="Progress" Width="200" Height="20" Minimum="0" Maximum="1" Margin="10" />
           <TextBlock Name="StatusText" Margin="10" Height="50"/>
           <StackPanel Orientation="Horizontal" FlowDirection="RightToLeft">
               <Button Name="CancelButton">Cancel</Button>
           </StackPanel>
       </StackPanel>
   </Grid>
</Window>

The progress bar is set to take progress values from 0 to 1, and has a TextBlock for displaying a status message.

It might seem like we are finished, but it is only part of what you need for a functional progress dialog. In trying to use the dialog, you quickly run into a problem - how to avoid blocking the UI thread while your operation proceeds. In Windows Forms, a common cheat was to periodically call Application.DoEvents() to allow the UI to update. While you can do something similar in WPF, it is ugly and best avoided.

Instead, you should do your work asynchronously in a separate thread. Given that, the next question becomes how to update the UI from your second thread, as WPF UI operations are not thread-safe, and you will get an exception if you try to interact with a control outside of the thread in which it was created. The solution? Use the Dispatcher. The Dispatcher basically lets you queue up function calls on the UI thread from your background thread.

To manage this communication, we will first create an interface for interacting with a progress dialog:

public interface IProgressContext
{
   void UpdateProgress(double progress);
   void UpdateStatus(string status);
   void Finish();
   bool Canceled { get; }
}

The UpdateProgress() method allows us to set the current progress value, UpdateStatus() allows us to display a text status message, Finish() lets us signal that our operation has completed, and the Canceled property allows us to check if the user has canceled the operation.

Now, the code-behind for the dialog:

public partial class ProgressDialog : Window, IProgressContext
{
   private bool canceled = false;

   public bool Canceled
   {
       get { return canceled; }
   }

   public ProgressDialog()
   {
       InitializeComponent();

       CancelButton.Click += new RoutedEventHandler(CancelButton_Click);
   }

   void CancelButton_Click(object sender, RoutedEventArgs e)
   {
       canceled = true;
       CancelButton.IsEnabled = false;
   }

   public void UpdateProgress(double progress)
   {
       Dispatcher.BeginInvoke(DispatcherPriority.Background,
           (SendOrPostCallback)delegate { Progress.SetValue(ProgressBar.ValueProperty, progress); }, null);
   }

   public void UpdateStatus(string status)
   {
       Dispatcher.BeginInvoke(DispatcherPriority.Background,
           (SendOrPostCallback)delegate { StatusText.SetValue(TextBlock.TextProperty, status); }, null);
   }

   public void Finish()
   {
       Dispatcher.BeginInvoke(DispatcherPriority.Background,
           (SendOrPostCallback)delegate { Close(); }, null);
   }
}

As you can see, we are basically just implementing the IProgressContext interface. We use the dispatcher to send along our progress updates to the UI thread. To use the dialog, launch a background thread to do your work, passing it a progress dialog as IProgressContext. Your work loop will look something like this:

for (int i = 0; i < 100; i++)
{
   if (myProgressContext.Canceled)
       break;

   myProgressContext.UpdateProgress((double)i / 100.0);
   myProgressContext.UpdateStatus("Doing Step " + i);
}

myProgressContext.Finish();

You can obviously get more fancy with your dialog - this is just a simple implementation to get started with.