Q:

Task WhenAll combined with ContinueWith not work as expected

I have a Winform project that inside of the winform class I have a property called DataBindingTasks like so.  
// create a task list to determine when tasks have finished during load
protected List<Task> DataBindingTasks = new List<Task>();

I have several async void methods that I am calling in the winform "Load" event that are all similar to the following.  
private async void BindSomething(int millSecToWait)
{
    var someTask = Task.Factory.StartNew(() =>
    {
        // do some work
        System.Threading.Thread.Sleep(millSecToWait);

        // return some list for binding
        return new List<int>();
    });
    // add the task to the task list
    DataBindingTasks.Add(someTask);

    // wait until data has loaded
    var listToBind = await someTask;

    // bind the data to a grid
}

I am calling the BindSomething methods on load.
I say methods because there are several of these binding types of methods that are called on load.  
private void Form_Load(object sender, EventArgs e)
{
    // async bind something and let UI continue
    // fire and forget
    BindSomething(5000);
    BindSomething(8000);
    BindSomething(2000);
    BindSomething(2000);

    // code to execute when all data binding tasks have completed
    Task.WhenAll(DataBindingTasks).ContinueWith((x) =>
    {
        // Do something after all async binding tasks have completed
    });
}

EXCEPT the ContinueWith code is executing even though all the tasks have not completed.
Here is a screen shot showing that all task are not complete. 

UPDATED 10/29
The problem is obviously deeper than the sample code above and the sample code above does not fully explain the true scenario.  
I will try to explain in greater detail but try to not make it to long.  
This is a Winform application.
We have created a base winform "BaseForm" that all other winforms will inherit from.
We have overridden the "OnLoad" event in the "BaseForm" so that we can call a new method that all inherited forms will have called "LoadData".
Since "LoadData" can have async method calls, the base form needs to know when the "LoadData" method is finished.
So in the base form was have some of the following: 
protected List<Task> DataBindingTasks = new List<Task>();

public event EventHandler DataBindingTasksComplete;
protected void OnDataBindingTasksComplete(EventArgs e)
{
    if (DataBindingTasksComplete != null)
    {
        DataBindingTasksComplete(this, e);
    }
    // now clear the list
    DataBindingTasks.Clear();
}

// NOTE: this is inside the OnLoad called before base.OnLoad(e)
Task.WhenAll(DataBindingTasks).ContinueWith((x) =>
{
    OnDataBindingTasksComplete(EventArgs.Empty);
});

The hope was that all inherited forms would add any of their "async" tasks to this list so that the base form could fire the "DataBindingTasksComplete" event so they would know that form has finished loading.  
The problem "as perceived to us at the time of the issue" was that the "WhenAll().ContinueWith" was not waiting until all the tasks on the list had completed.
BUT as someone noted, the list might have changed.
So here is most likely what happened.
There are 4 "BindSomething" methods that are marked async all called from the Form_Load
The 2nd or so line down inside the "BindSomething" method is used to add a task to the "BaseForm.DataBindingTasks" list.
Since each of these calls are marked async, the Form_Load continues to call all 4 as a "fire and forget".
After that, it returns back to the BaseForm OnLoad which then looks at the "DataBindingTasks" list to see if all tasks have completed.
My best guess is that one of the "BindSomething" methods was in the middle of adding its task to the list yet the Base.OnLoad has already started looking at the list.  
I could add 4 "fake" tasks (like thread sleep) to the list even before calling the "BindSomething" methods as "place holders" and then inside the "BindSomething" methods swap out the "fake" tasks with the "real" tasks.
This seams messy and most likely will cause other issues.
The most likely fix is to not use a task list / WhenAll.ContinueWith and instead call the load data with "await" and then raise the event on the next line.  

A:

The async void methods are called as fire-and-forget, and there is no way to wait for them, that's why your delegate don't wait properly - it simply can't do that. So you need some changes in your code.
Update: @Servy noted the main problem in your code which I've missed, thanks for him:
DataBindingTasks.Add(someTask);

This operation isn't thread-safe! You simply losing some of your tasks during parallel calls for Add method. You need to change this: by using lock, by using ConcurrentCollection or by using data separation: assign a task to array by different indexes so parallel tasks aren't intersect each other.
First of all, you shouldn't use the StartNew in this case, use the Task.Run, otherwise you can met some problems in your app.
Second thing is that you can make the Load method async and await it, so your UI wouldn't freeze, and you can switch the signature for your BindSomething methods to became awaitable, as @digimunk mentioned:
// note that we return the task here
private async Task BindSomething(int millSecToWait)
{
    // use Task.Run in this case
    var someTask = Task.Run(() =>
        {
            // Some work
            System.Threading.Thread.Sleep(millSecToWait);
            // return some list for binding
            return new List<int>();
        });

    DataBindingTasks.Add(someTask);

    // wait until data has loaded
    var listToBind = await someTask;

    // bind the data to a grid
}

// async void for the event handler
private async void Load()
{
    // start tasks in fire-and-forget fashion
    BindSomething(5000);
    BindSomething(8000);
    BindSomething(2000);

    // code to execute when all data binding tasks have completed
    await Task.WhenAll(DataBindingTasks);

    // Do something after all binding is complete
}

In this case you can await the Load method safely.

