Perché dovrei usare IQueryable <T> sopra Lista <T> in LINQ to SQL

Question

Eventuali duplicati:
To return IQueryable<T> or not return IQueryable<T>

devo LINQ to SQL repository implementato come segue. Il metodo GetAll sta eseguendo un elenco generico anziché IQueryable. Tuttavia, nella maggior parte degli esempi e delle esercitazioni, viene mostrato che il pozzetto restituisce IQueryable. Qual è il vantaggio di ripristinare IQueryable?

using System.Linq; 
namespace RepositoryLayer 
{ 
public interface IRepository<T> where T : class 
{ 
    //System.Linq.IQueryable<T> GetAll(); 
    System.Collections.Generic.List<T> GetAll(); 
} 

public class Repository<T> : IRepository<T> where T : class 
{ 
    public System.Data.Linq.DataContext Context 
    { 
     get; 
     set; 
    } 

    //public virtual System.Linq.IQueryable<T> GetAll() 
    //{ 
    // //GetAll is returning generic Queryable<T>. 
    // System.Linq.IQueryable<T> allItems = Context.GetTable<T>(); 
    // return allItems; 
    //} 

    public virtual System.Collections.Generic.List<T> GetAll() 
    { 

     System.Linq.IQueryable<T> allItems = Context.GetTable<T>(); 
     return allItems.ToList(); 
    } 


    } 
} 

business layer

namespace BusinessLayerProject 
{ 
public class AccountBusiness 
{ 
    //IRepository<T> 
    RepositoryLayer.IRepository<RepositoryLayer.Account> accountRepository; 
    public AccountBusiness(RepositoryLayer.IRepository<RepositoryLayer.Account> repo) 
    { 
     accountRepository = repo; 
    } 

    //public List<RepositoryLayer.Account> GetAllAccounts() 
    //{ 

    // //LibraryManagementClassesDataContext context = new LibraryManagementClassesDataContext(); 
    // //List<RepositoryLayer.Account> accontList = context.Accounts.ToList(); 

    // System.Linq.IQueryable<RepositoryLayer.Account> acc = accountRepository.GetAll(); 
    // return acc.ToList(); 
    //} 

    public List<RepositoryLayer.Account> GetAllAccounts() 
    { 
     List<RepositoryLayer.Account> acc = accountRepository.GetAll(); 
     return acc; 
    } 


} 
} 

LETTURA

1. Advantage of creating a generic repository vs. specific repository for each object?

Answer 1

Utilizzando IQueryable diamo LINQ spostare po 'di lavoro supplementare nella DB con la creazione di diverse query SQL. per esempio. quando si prova qualcosa come GetAll().Where(condition) e si utilizza tutti gli elementi vengono interrogati dal DB e dove viene verificata la condizione lato applicazione. Quando si utilizza IQueryable può essere spostato in DB e gli elementi appropriati sono di ritorno direttamente da lì.

Answer 2

IQueryable estende IEnumerable. Entrambi non proiettano/gonfiano i loro dati finché non vengono iterati, mentre gli oggetti IList estraggono tutti i loro dati e vengono popolati quando vengono assegnati.

Quindi è una distinzione "pigro-carico" e "carico-carico".

Answer 3

Becasue IList è - ah - non intelligente?

Ecco come fare:

IIF yo uexport IQueryable - sul metodo Get è l'unico metodo che mai bisogno. Tutti i parametri passano a IQueryable e PERCHÉ UNA ESECUZIONE DIFFERITA FINE NEL LIVELLO SQL.

Export IList e si ottiene tutto e poi filtrare - in memoria, che è tanto una perversione di LINQ, come si arriva.

Il vero trucco è che se io makcal vostro metodo Get e quindi .Dove, OrderBy, che entra nella dichiarazione di sql nel database.