Async chiamata entro funzione sincrona

Question

sto cercando di popolare la cache in modo asincrono

static ConcurrentDictionary<string, string[]> data = new ConcurrentDictionary<string, string[]>(); 

public static async Task<string[]> GetStuffAsync(string key) 
{ 
    return data.GetOrAdd(key, async (x) => { 
     return await LoadAsync(x); 
    }); 
} 

static async Task<string[]> LoadAsync(string key) {....} 

ma questo mi dà l'errore:

Cannot convert async lambda expression to delegate type 'System.Func'.

An async lambda expression may return void, Task or Task, none of which are convertible to 'System.Func'.

quanto ho capito che questo è perché GetOrAdd() non è asincrona. Come posso risolvere il problema?

Aggiornamento: LazyAsync suggerito nei commenti lavorerà nel mio esempio banale. Oppure, soluzione come questo (può sicuramente vivere con un certo overhead introduce):

public static async Task<string[]> GetStuffAsync(string key) 
{ 
    string[] d = null; 
    if (!data.ContainsKey(key)) 
     d = await LoadAsync(key); 
    return data.GetOrAdd(key, d); 
} 

La domanda allora diventa ha fatto Microsoft ha appena non hanno tempo per aggiornare tutte le interfacce per supportare asincrona o io sto cercando di fare qualcosa di profondamente sbagliato (e ConcurrentDictionary non dovrebbe avere GetOrAddAsync())?

Answer 1

I metodi asincroni (o lambda) possono solo restituire void o Task o Task<T> ma il tuo lambda restituisce string[] e quindi il compilatore ti impedisce.

await la parola chiave è ottimizzata per continuare in modo sincrono quando l'attività è già completata. Quindi, un'opzione è quella di memorizzare l'attività stessa nel dizionario e non preoccuparti di attendere ancora e ancora l'attività completata.

private static ConcurrentDictionary<string, Task<string[]>> data = 
    new ConcurrentDictionary<string, Task<string[]>>(); 

public static Task<string[]> GetStuffAsync(string key) 
{ 
    return data.GetOrAdd(key, LoadAsync); 
} 

E quando lo fai

var item = await GetStuffAsync(...); 

prima volta sarà (a) aspettare che termina la Task cache --Ci dopo che continuerà in modo sincrono.

Dovrai pensare a cosa dovrebbe accadere quando LoadAsync non riesce. Perché stiamo memorizzando nella cache l'attività restituita da LoadAsync; se fallisce, memorizziamo stupidamente l'operazione fallita. Potrebbe essere necessario gestirlo.