C#

Task<List<ProjectHeaderEntity>> projectsTask = Task.Run(() => AppCore.BizObject.GetProjectHeaders(AppCore.AppCompany.Id).ToList());
Task<List<NavigationGroupEntity>> jobsTask = Task.Run(() => AppCore.BizObject.GetJobListHeaders(AppCore.AppCompany.Id).ToList());

// At this point, both tasks have started running.
// Since you know the number of tasks, you don't need Task.WhenAll; just await both tasks.

List<ProjectHeaderEntity> projects = await projectsTask;
List<NavigationGroupEntity> jobs = await jobsTask;

var dialogVm = new VendorsByProjectAndJobReportViewModel(projects, jobs);
DialogResultEx result = DialogService.ShowDialog(dialogVm, typeof(MainWindowView));

Richard Deeming wrote:

ConfigureAwait(false) tells the code that you don't want to us the same "execution context" to continue running the method after the task has completed.

Richard Deeming wrote:

I'd also be inclined to drop the closures.

Richard Deeming wrote:

And you don't really need Task.WhenAll here at all.

Kevin Marois wrote:

What's a 'closure'?

public void Foo()
{
    List<ProjectHeaderEntity> projects = null;
    await Task.Run(() => { projects = AppCore.BizObject.GetProjectHeaders(AppCore.AppCompany.Id).ToList(); });
    Console.WriteLine(projects.Count);
}

private sealed class <>_SomeRandomGeneratedName
{
    public List<ProjectHeaderEntity> projects;
    public Action TheAction;
    public void TheActualMethod()
    {
        this.projects = AppCore.BizObject.GetProjectHeaders(AppCore.AppCompany.Id).ToList();
    }
}

public void Foo()
{
    var closure = new <>_SomeRandomGeneratedName();
    closure.TheAction = new Action(closure.TheActualMethod);
    await Task.Run(closure.TheAction);
    Console.WriteLine(closure.projects.Count);
}

public void Foo()
{
    List<ProjectHeaderEntity> projects = await Task.Run(() => AppCore.BizObject.GetProjectHeaders(AppCore.AppCompany.Id).ToList());
    Console.WriteLine(projects.Count);
}

private static Func<List<ProjectHeaderItem>> TheCachedDelegate;

private static List<ProjectHeaderEntity> TheActualMethod()
{
    return AppCore.BizObject.GetProjectHeaders(AppCore.AppCompany.Id).ToList();
}

public void Foo()
{
    if (TheCachedDelegate == null)
    {
        TheCachedDelegate = new Func<List<ProjectHeaderItem>>(TheActualMethod);
    }
    
    List<ProjectHeaderEntity> projects = await Task.Run(TheCachedDelegate);
    Console.WriteLine(projects.Count);
}

Kevin Marois wrote:

I thought that WITHOUT WhenAll, the first would run, then the other one.

await Task.Run(() => ...); // Waits for this one to finish...
await Task.Run(() => ...); // then runs this one and waits for it to finish...
DoSomething(); // then does this.

Task a = Task.Run(() => ...); // Starts this one...
Task b = Task.Run(() => ...); // then starts this one...
await a; // then waits for the first one to finish...
await b; // then waits for the second one to finish...
DoSomething(); // then does this.

Task a = Task.Run(() => ...); // Starts this one...
Task b = Task.Run(() => ...); // then starts this one...
await Task.WhenAll(new[] { a, b }); // then waits for both tasks to finish...
DoSomething(); // then does this.

private async Task LoadProjects(VendorsByProjectAndJobReportViewModel vm)
{
    var projects = await Task.Run(() => AppCore.BizObject.GetProjectHeaders(AppCore.AppCompany.Id).ToList()).ConfigureAwait(false);
    vm.Projects = projects;
}

private async Task LoadJobs(VendorsByProjectAndJobReportViewModel vm)
{
    var jobs = await Task.Run(() => AppCore.BizObject.GetJobListHeaders(AppCore.AppCompany.Id).ToList()).ConfigureAwait(false);
    vm.Jobs = jobs;
}

private async Task ShowVendorsByProjectAndJobReport()
{
    WaitIndicatorVisibility = Visibility.Visible;
    
    var dialogVm = new VendorsByProjectAndJobReportViewModel();
    var tasks = new List<Task>
    {
        LoadProjects(dialogVm),
        LoadJobs(dialogVm),
    };
    
    await Task.WhenAll(tasks); // NB: No "ConfigureAwait" here
    DialogResultEx result = DialogService.ShowDialog(dialogVm, typeof(MainWindowView));
}

using System;
using System.Linq;

static class Program
{
    static int solution(int[] A)
    {
        ...
        return maxSize + 1;
    }
    
    static void Main(string[] args)
    {
        int[] A = { 5, 9, 2, 7 };
        Console.WriteLine(solution(A));
    }
}

static async Task Main()
{
    Console.WriteLine("Calling Test()");
    Task t = Test();
    Console.WriteLine("After Test");
    await t;
}

private static async Task Test()
{
    Console.WriteLine("Calling GetSomeData()");
    var results = await GetSomeData();
    Console.WriteLine($"Results: {results}");
}

private static async Task<int> GetSomeData()
{
    int x = 0;
    for (; x < 9000; x++)
    {
        await Task.Delay(5);
    }
    
    return x;
}

Calling Test()
Calling GetSomeData()
After Test
{delay}
Results: 9000

private static Task<int> GetSomeData()
{
    int x = 0;
    for (; x < 900000000; x++)
    {
    }

    Thread.Sleep(5000);

    return Task.FromResult<int>(x);
}

private static async Task<int> GetSomeData()
{
    await Task.Yield();
    
    int x = 0;
    for (; x < 900_000_000; x++)
    {
    }
    
    await Task.Delay(5000);
    return x;
}

Richard Deeming wrote:

o let the caller continue before the loop has finished, you'd need to yield control before starting the loop.