C# Task Return output

I think it is time for you to take the step to async/await. This will make your live much easier.

Somewhere in your code you want to start several tasks and wait for all tasks to complete without blocking your user interface. In your example this is GetResult.

You want GetResult to return an object of DataTable. If you want to use async await, you declare the function GetResult and return a Task, like this:

public async Task<DataTable> GetResultAsync(SomeVariable someVariable) {...}

It is quite common to name your async functions with the word async at the end

In this function you can start tasks, do other things while these tasks are running and wait for the tasks to finish. This waiting is called "await".

You can only await for a Task or a Task object, so you await for a function that returns Task.

Task.WaitAll doesn't return Task, but void. So you can't await for Task.Waitall.

Better is to await for Task.WhenAll. That function returns a Task, and thus you can await for it.

public async Task<DataTable> GetResultAsync(SomeVariable someVariable)
{
    var task = Task.Run( () =>
    {
        DataTable matchedData = new DataTable();
        matchedData = DoTask(someVariable);
        return matchedData;
    }
}

If you want you can still use Task.Factory.StartNew, see MSDN for discussions why they nowadays prefer Task.Run

This function will get you one result. If you want to call if, you'll have to make the caller function also async and let it return Task or Task. Its caller should also be async etc. until you get to the event handler. This is the only one who may return void:

private async void OnButton1_clicke(object Sender, ...)
{
    try
    {
        await ProcessAllInputsAsync(...)
    }
    catch (ArgumentException exc)
    {
        ProcessArgumentException(...)
    }
    catch (Exception exc)
    {
         ProcessOtherException(...)
    }           
}

// first example: no parallel processing:
private async Task ProcessAllInputsAsync(...)
{   
    foreach (SomeVariable someVariable in GetSomeVariables(...))
    {
        DataTable dataTable = await GetResultAsync(...);
        ProcessDataTable(dataTable);
    }
}

// or do parallel processing: start several tasks and wait until all ready:
private async Task ProcessAllInputsAsync(...)
{ 
    List<Task<DataTable>> tasks = new List<Task<DataTable>>();  
    foreach (SomeVariable someVariable in GetSomeVariables(...))
    {
        tasks.Add(GetResultAsync(someVariable);
    }
    // all tasks are started, await for all to finish:
    await Task.WhenAll(tasks.ToArray());
    // REMEMBER: you can only await for a Task or Task<T>
    // Task.WhenAll returns a Task, so you can await for it
    // Task.WaitAll returns void, so you can't await for it.

    // now that all tasks are finished, get the results:
    // Each Task<TResult> has the result in property Task.Result
    // The result of a Task<TResult> is a TResult:
    IEnumerable<TResult> fetchedDataTables = tasks.Select(task => task.Result);

    // you can process it here if you want or do other things with it:
    foreach (DataTabe fetchedDataTable in fetchedDataTables)
    {
        ProcessFetchedDataTable(fetchedDataTable);
    }
}

See that you got rid of all ContinueWith etc stuff. It is replace by await, followed by the next statement where the result of the task is available in Task.Result.

Be aware: if you do a Task.WhenAll, and one of the tasks you are waiting for throws an exception, you get an AggregateException where all exceptions thrown by all tasks are grouped in property InnerExceptions. So if you want you can catch the AggregateException and foreach all innerexceptions to see which task threw which exceptions.