Entity Framework Queryable async

Sto lavorando su alcune cose dell'API Web utilizzando Entity Framework 6 e uno dei metodi del mio controller è "Ottieni tutto" che si aspetta di ricevere il contenuto di una tabella dal mio database come file IQueryable<Entity>. Nel mio repository mi chiedo se ci sia qualche ragione vantaggiosa per farlo in modo asincrono dato che sono nuovo nell'uso di EF con async.

Fondamentalmente si riduce a

 public async Task<IQueryable<URL>> GetAllUrlsAsync()
 {
    var urls = await context.Urls.ToListAsync();
    return urls.AsQueryable();
 }

vs

 public IQueryable<URL> GetAllUrls()
 {
    return context.Urls.AsQueryable();
 }

La versione asincrona produrrà effettivamente vantaggi in termini di prestazioni qui o sto incorrendo in un sovraccarico non necessario proiettando prima su un elenco (usando async, intendiamoci) e POI andando su IQueryable?

Il problema sembra essere che hai frainteso il funzionamento di async / await con Entity Framework.

Informazioni su Entity Framework

Quindi, diamo un'occhiata a questo codice:

public IQueryable<URL> GetAllUrls()
{
    return context.Urls.AsQueryable();
}

ed esempio di utilizzo:

repo.GetAllUrls().Where(u => <condition>).Take(10).ToList()

Cosa succede lì?

1. Stiamo ottenendo IQueryableoggetto (non ancora accedendo al database) utilizzandorepo.GetAllUrls()
2. Creiamo un nuovo IQueryableoggetto con la condizione specificata usando.Where(u => <condition>
3. Creiamo un nuovo IQueryableoggetto con il limite di paging specificato utilizzando.Take(10)
4. Recuperiamo i risultati dal database utilizzando .ToList(). Il nostro IQueryableoggetto è compilato in sql (like select top 10 * from Urls where <condition>). E il database può utilizzare gli indici, il server sql ti invia solo 10 oggetti dal tuo database (non tutti i miliardi di URL memorizzati nel database)

Ok, diamo un'occhiata al primo codice:

public async Task<IQueryable<URL>> GetAllUrlsAsync()
{
    var urls = await context.Urls.ToListAsync();
    return urls.AsQueryable();
}

Con lo stesso esempio di utilizzo abbiamo ottenuto:

1. Stiamo caricando in memoria tutti i miliardi di URL memorizzati nel tuo database utilizzando await context.Urls.ToListAsync();.
2. Abbiamo un overflow di memoria. Il modo giusto per uccidere il tuo server

Informazioni su async / await

Perché è preferibile utilizzare async / await? Diamo un'occhiata a questo codice:

var stuff1 = repo.GetStuff1ForUser(userId);
var stuff2 = repo.GetStuff2ForUser(userId);
return View(new Model(stuff1, stuff2));

Che succede qui?

1. A partire dalla linea 1 var stuff1 = ...
2. Inviamo la richiesta al server sql per cui vogliamo ottenere qualcosa1 userId
3. Aspettiamo (il thread corrente è bloccato)
4. Aspettiamo (il thread corrente è bloccato)
5. .....
6. Il server SQL inviaci la risposta
7. Passiamo alla riga 2 var stuff2 = ...
8. Inviamo una richiesta al server sql per cui vogliamo ottenere qualcosa2 userId
9. Aspettiamo (il thread corrente è bloccato)
10. E di nuovo
11. .....
12. Il server SQL inviaci la risposta
13. Rendiamo la vista

Quindi diamo un'occhiata a una versione asincrona di esso:

var stuff1Task = repo.GetStuff1ForUserAsync(userId);
var stuff2Task = repo.GetStuff2ForUserAsync(userId);
await Task.WhenAll(stuff1Task, stuff2Task);
return View(new Model(stuff1Task.Result, stuff2Task.Result));

Che succede qui?

1. Inviamo una richiesta al server sql per ottenere stuff1 (riga 1)
2. Inviamo una richiesta al server sql per ottenere stuff2 (riga 2)
3. Attendiamo risposte dal server sql, ma il thread corrente non è bloccato, può gestire le query di altri utenti
4. Rendiamo la vista

Modo giusto per farlo

Quindi buon codice qui:

using System.Data.Entity;

public IQueryable<URL> GetAllUrls()
{
   return context.Urls.AsQueryable();
}

public async Task<List<URL>> GetAllUrlsByUser(int userId) {
   return await GetAllUrls().Where(u => u.User.Id == userId).ToListAsync();
}

Nota che devi aggiungere using System.Data.Entityper utilizzare il metodo ToListAsync()per IQueryable.

Nota che se non hai bisogno di filtri, paging e cose del genere, non devi lavorare con IQueryable. Puoi semplicemente usare await context.Urls.ToListAsync()e lavorare con materialized List<Url>.

C'è un'enorme differenza nell'esempio che hai pubblicato, la prima versione:

var urls = await context.Urls.ToListAsync();

Questo è un male , fondamentalmente lo fa select * from table, restituisce tutti i risultati in memoria e quindi applica il wherecontro quello nella raccolta della memoria invece di farlo select * from table where...contro il database.

Il secondo metodo non raggiungerà effettivamente il database finché non viene applicata una query al IQueryable(probabilmente tramite un'operazione in .Where().Select()stile linq che restituirà solo i valori db che corrispondono alla query.

Se i tuoi esempi fossero comparabili, la asyncversione sarà generalmente leggermente più lenta per richiesta poiché c'è più overhead nella macchina a stati che il compilatore genera per consentire la asyncfunzionalità.

Tuttavia la principale differenza (e vantaggio) è che la asyncversione consente più richieste simultanee in quanto non blocca il thread di elaborazione mentre è in attesa del completamento dell'IO (query db, accesso ai file, richiesta web ecc.).

Per farla breve,
IQueryableè progettato per posticipare il processo RUN e prima costruire l'espressione insieme ad altre IQueryableespressioni, quindi interpreta ed esegue l'espressione nel suo insieme.
Ma il ToList()metodo (o alcuni tipi di metodi come quello), sono destinati a eseguire l'espressione istantaneamente "così com'è".
Il tuo primo metodo ( GetAllUrlsAsync) verrà eseguito immediatamente, perché è IQueryableseguito da ToListAsync()metodo. quindi viene eseguito istantaneamente (asincrono) e restituisce un mucchio di IEnumerables.
Nel frattempo il tuo secondo metodo ( GetAllUrls), non verrà eseguito. Invece, restituisce un'espressione e CALLER di questo metodo è responsabile di eseguire l'espressione.