nidificati Async/attendono Non sembra essere Scaling

Question

Ho il seguente codice (semplificato):

public async Task GetData(DomainObject domainObject, int depth) 
{ 
    // This async operation is really quick, and there's usually like five. 
    IEnumerable<TierOne> tierOnes = await domainObject.GetTierOnesAsync(); 

    var tierOneTasks = tierOnes.Select(async tierOne => 
    { 
    // This async operation is really quick and there's usually like three. 
    IEnumerable<TierTwo> tierTwos = await tierOne.GetTierTwosAsync(); 

    if (depth <= TierTwoDepth) 
     return; 

    var tierTwoTasks = tierTwos.Select(async tierTwo => 
    { 
     // This async operation is usually fast, and there's usually >= 100. 
     IEnumerable<TierThree> tierThrees = await tierTwo.GetTierThreesAsync(); 

     if (depth <= TierThreeDepth) 
     return; 

     var tierThreeTasks = tierThrees.Select(async tierThree => 
     { 
     // This async operation is SLOW, and there's usually.. 50? 
     await tierThree.GetTierFoursAsync(); 
     }); 

     await Task.WhenAll(tierThreeTasks.ToArray()); 
    }); 

    await Task.WhenAll(tierTwoTasks.ToArray()); 
    }); 

    await Task.WhenAll(tierOneTasks.ToArray()); 
} 

base al largo di quello che ho visto, non sembra essere scalare molto bene. Tutte le operazioni di Async sono operazioni "true async", il che significa che sono tutti I/O.

Sto usando Async/Attendere in modo errato per questo scenario? Basandomi sulle mie attuali osservazioni, non è il ridimensionamento a ciò che mi aspetterei. TPL DataFlow sarebbe la mia soluzione?

Answer 1

Per una chiamata singola a GetData, le chiamate asincrone/attese annidate non introdurranno alcuna concorrenza. Recuperate tutti i tierOnes, quindi tutti i tierTwos per tierOne- # 1, quindi tutti i tierThrees per tierTwo- # 1 e così via, tutti eseguiti in sequenza (sebbene ci possa essere qualche concorrenza all'interno dei metodi Async di GetTier *).

Se si desiderano richieste simultanee, quindi TPL Dataflow è davvero una soluzione migliore.