Asynchronously assembling a complex object Sanity check needed, as I'm still very unfamiliar with the nuances behind async/await and how they relate to more traditional Task / TPL code.
I have a high-level repository layer which is assembling a business object from various lower-level repositories.  As a business decision, we are doing keyed lookups at the data layer and assembling the composite object in code.  In the following code, &quot;Account&quot; is the business object, and the various _tAccountXXXRepo objects are all patterned similarly to this (we are using NPoco):
public class T_AccountMapperRepository : BaseNPocoRepository&lt;T_AccountMapper&gt;
    , IRetrieveMany&lt;T_AccountMapper&gt;
    , IRetrieve&lt;AccountId, T_AccountMapper&gt;
{
    public T_AccountMapperRepository(IDatabase database) : base(database)
    {
    }

    public async Task&lt;T_AccountMapper&gt; Retrieve(AccountId input)
    {
        return await Database.QueryAsync&lt;T_AccountMapper&gt;()
            .First(x =&gt; x.AccountId == input)
            .ConfigureAwait(false);
    }
}

The code to fetch the different values can be logically executed in parallel, and I am wondering if this implementation is the correct pattern to do so:  (the various methods being called on the Account object are thread-safe as well)
public async Task&lt;Account&gt; Retrieve(AccountId input1, DateTime input2)
{
    var account = new Account();

    await Task.WhenAll(
        _tAccountMapperRepo.Retrieve(input1)
            .ContinueWith(async result =&gt; account.SetAccountMap(await TranslateAccountMap(result))),

        _tPaymentRedirectionRepo.Retrieve(input1, input2)
            .ContinueWith(async result =&gt; account.ChangePayerToAccount(await TranslatePaymentRedirection(result))),

        _tAccountAncestorRepo.Retrieve(input1, input2)
            .ContinueWith(async result =&gt; await _tAccountMapperRepo.Retrieve((await result).AncestorId))
            .ContinueWith(async result =&gt; account.MoveAccountToNewParentAccountMap(await TranslateAccountMap(await result))),

        _tAccountRepo.Retrieve(input1)
            .ContinueWith(async result =&gt; await _tAccountTypeRepo.Retrieve((await result).TypeId))
            .ContinueWith(async result =&gt; account.SetAccountType(await TranslateAccountType(await result)))
    );

    return account;
}

Any method that is labelled with TranslateXXX all look similar to this:
private static async Task&lt;AccountMap&gt; TranslateAccountMap(Task&lt;T_AccountMapper&gt; mapTask)
{
    if (!mapTask.IsCompletedSuccessfully)
        throw new InvalidOperationException(nameof(mapTask), mapTask.Exception);

    var map = await mapTask;

    return new AccountMap(map.AccountId, map.Login, map.Namespace);
}

My main concerns are mixing Task and async/await, and whether or not my async &amp; awaiting is re-introducing an element of synchronicity in what I'm hoping to make a very asynchronous process.  My end goal is that as many various properties as possible are fetched in parallel and assembled
As for me it looks fine except one thing. You have already completed Task in .ContinueWith block, thus you may use .Result then instead of await and avoid redundant async State Machine.
By the way, if you're using async/await, probably there's no continuations needed.
Consider this continuations-free implementation of 1st Task.WhenAll() job.
public async Task&lt;Account&gt; Retrieve(AccountId input1, DateTime input2)
{
    var account = new Account();

    // probably try-catch wrapper maybe useful here as replacement of !mapTask.IsCompletedSuccessfully
    await Task.WhenAll((Func&lt;Task&gt;)(async () =&gt;
    {
        T_AccountMapper map = await _tAccountMapperRepo.Retrieve(input1);
        // continuation:
        AccountMap accountMap = new AccountMap(map.AccountId, map.Login, map.Namespace);
        account.SetAccountMap(accountMap);
    })
    //, (Func&lt;Task&gt;)(async() =&gt; {...})
    );

    return account;
}

As you can see, TranslateAccountMap method isn't needed anymore.
Finally, it's up to you.
P.S. Here's a useful link.