Using Task for responsive UI in WPF

Blocking of the UI thread in a WPF application causes the application to become unresponsive. It is a common problem with several solutions, but usage of Task is in my opinion the most elegant solution because of readability and code brevity.
For this example we have a simple WPF application with a button that starts a long running loop. A busy indicator is displayed while the loop is running.

```csharp
_busyIndicator.IsBusy = true;

for (var i = 0; i < 100; i++)
{
System.Threading.Thread.Sleep(50);
}

_busyIndicator.IsBusy = false;
```

As written, this code will freeze the app for the duration of the loop since it blocks execution of the UI thread. The solution is to run the loop Asynchronously and using Task is the easiest way to accomplish it in this case.

```csharp
_busyIndicator.IsBusy = true;

var T = new Task(() =>
{
for (var i = 0; i < 100; i++)
{
System.Threading.Thread.Sleep(50);
}
});

T.Start();

_busyIndicator.IsBusy = false;
```

However, this bit of code will crash the application because we have not passed control back to the context of the UI thread. The ‘Task.ContinueWith’ method can be used to serve that purpose.

```csharp
var T = new Task(() =>
{
for (var i = 0; i < 100; i++)
{
System.Threading.Thread.Sleep(50);
}
});

T.ContinueWith(antecedent => _busyIndicator.IsBusy = false, TaskScheduler.FromCurrentSynchronizationContext());
```

Running the application will now result in complete responsiveness. You can move, resize, or perform other operations while the loop is running. However, there are cases where CPU intensive loops may cause the busy indicator to not be displayed. In WPF, the UI render events are queued to prevent issues related to multiple execution of the same event. To prevent this, we want to make sure that the busy indicator is displayed. And for that we can use a timer event.

```csharp
private System.Windows.Threading.DispatcherTimer _timer = null;
public MainWindow()
{
InitializeComponent();
_timer = new DispatcherTimer();
_timer.IsEnabled = false;
_timer.Tick += new System.EventHandler(RunTask);
}

private void StartProcess(object sender, RoutedEventArgs e)
{
_busyIndicator.IsBusy = true;
_timer.Interval = new TimeSpan(0,0,0,0,100);
_timer.Start();
// go back to the user thread, giving the busy indicator a chance to come up before the next timer tick event
}

void RunTask(object sender, System.EventArgs e)
{
_timer.IsEnabled = false;

var T = new Task(() =>
{
for (var i = 0; i < 100; i++)
{
System.Threading.Thread.Sleep(50);
}
});

T.ContinueWith(antecedent => _busyIndicator.IsBusy = false, TaskScheduler.FromCurrentSynchronizationContext());
T.Start();
}
```

So, when the user clicks the button, the busy indicator is set to true first, the timer is started, and once it has ticked the Task is called. Using the timer event in this manner ensures that the loop will not be executed until the busy indicator is rendered.

The complete source code for this example can be found in our [github repository](https://github.com/yojimbocorp/blog-posts/tree/master/BusyIndicator).