Cancellable progress form using async/await
Clean code, easy to follow its meaning. Some minor remarks:

var progressHandler = new Progress&lt;string&gt;(value =&gt; MessageLabel.Text = value);
var progress = progressHandler as IProgress&lt;string&gt;;


This looks like you can just define it as

IProgress&lt;string&gt; progressHandler = new Progress(value =&gt; MessageLabel.Text = value);


Or just a Progress&lt;string&gt; type, really:

var progressHandler = new Progress(value =&gt; MessageLabel.Text = value);


Unless I'm mistaking, you don't actually need it as an interface. Note that I also removed the explicit type parameter since that should be inferred from the argument passed to it.



MessageLabel.Text = @"Cancelled!";


The verbatim string isn't necessary here



if (token.IsCancellationRequested)
{
    token.ThrowIfCancellationRequested();
}


This seems redundant to me.

It should be either this

if (token.IsCancellationRequested)
{
    throw new OperationCanceledException();
}


or this:

token.ThrowIfCancellationRequested()


This is also reinforced by the documentation



private async void PerformTasks()


Asynchronous methods should return Task or Task&lt;T&gt;, the former being for traditional void methods and the latter being for methods with T return type. 

The reason for this is that a void method cannot be awaited (since it doesn't return a Task) and will in effect be a fire-and-forget kind of thing: it will start executing your asynchronous code on a separate thread and continue doing business as normal. However once the main thread reaches its end, the application will exit regardless of whether or not your asynchronous code has finished as well. This obviously leads to nasty bugs.

You won't notice this in this case because you're using a GUI which means there will always be a main thread active (as long as the application runs).

However in case you ever want to re-use this code for a console application or just in a class library where you don't know the client, I would suggest making it async Task just for good measure.

The only exception to this are asynchronous event handlers since they have to adhere to the convention that event handlers return void. This also explains why events are "dangerous" to use in asynchronous code.