IEnumerable<T> vs IQueryable<T> - kluczowa różnica w LINQ
To jest jedno z najczęściej zadawanych pytań na rozmowach .NET - fundament rozumienia, jak LINQ to Entities (EF Core) w ogóle działa.
Podstawowa definicja - IQueryable<T> dziedziczy po IEnumerable<T>
public interface IEnumerable<T> : IEnumerable
{
IEnumerator<T> GetEnumerator();
}
public interface IQueryable<T> : IEnumerable<T>, IQueryable
{
Type ElementType { get; }
Expression Expression { get; }
IQueryProvider Provider { get; }
}
IQueryable<T> jest IEnumerable<T> (dziedziczy po nim) plus dodatkowe informacje potrzebne do zbudowania i przetłumaczenia zapytania na inny język (najczęściej SQL).
Gdzie wykonuje się filtrowanie - kluczowa różnica
// IEnumerable - filtrowanie W PAMIĘCI, w C#
IEnumerable<Order> orders = context.Orders.ToList(); // ⚠️ ToList() już pobrał WSZYSTKO z bazy!
var filtered = orders.Where(o => o.Status == "Pending"); // filtrowanie odbywa się TERAZ, w pamięci .NET
// IQueryable - filtrowanie NA BAZIE DANYCH, w SQL
IQueryable<Order> query = context.Orders; // jeszcze BRAK zapytania SQL
var filtered2 = query.Where(o => o.Status == "Pending"); // WCIĄŻ brak SQL - tylko rozbudowa wyrażenia
var result = filtered2.ToList(); // DOPIERO TERAZ generowany i wykonywany SQL: WHERE Status = 'Pending'
To jest fundamentalna praktyczna konsekwencja: IEnumerable pobiera wszystkie dane, a potem filtruje w C#; IQueryable tłumaczy filtr na SQL i filtruje bezpośrednio w bazie danych, przesyłając przez sieć tylko wynikowe wiersze.
Demonstracja problemu wydajnościowego - klasyczne pytanie-pułapka
// ❌ BARDZO NIEEFEKTYWNE
public List<Order> GetPendingOrders(AppDbContext context)
{
IEnumerable<Order> orders = context.Orders; // niejawna konwersja na IEnumerable!
return orders.Where(o => o.Status == "Pending").ToList();
}
// Co się faktycznie dzieje: EF Core widzi typ IEnumerable, więc NIE MOŻE zbudować SQL z filtrem
// -> pobiera WSZYSTKIE zamówienia z całej tabeli (SELECT * FROM Orders, BEZ WHERE)
// -> filtrowanie "Status == Pending" dzieje się DOPIERO w pamięci C#, po pobraniu WSZYSTKIEGO
// ✅ EFEKTYWNE
public List<Order> GetPendingOrders(AppDbContext context)
{
IQueryable<Order> orders = context.Orders; // pozostaje IQueryable
return orders.Where(o => o.Status == "Pending").ToList();
}
// SQL: SELECT * FROM Orders WHERE Status = 'Pending' - filtr wykonany NA BAZIE,
// przez sieć leci TYLKO pasujące wiersze
To jest realny, częsty bug w kodzie produkcyjnym - jeśli gdziekolwiek po drodze zmienisz typ zmiennej na IEnumerable<T> (albo wywołasz metodę przyjmującą IEnumerable<T> zamiast IQueryable<T>), tracisz możliwość tłumaczenia dalszych operacji na SQL - wszystko od tego momentu wykonuje się w pamięci, po pobraniu (potencjalnie) całej tabeli.
Jak to się dzieje "pod spodem" - Expression vs Func
// IEnumerable.Where przyjmuje SKOMPILOWANY delegat
public static IEnumerable<T> Where<T>(this IEnumerable<T> source, Func<T, bool> predicate)
{
foreach (var item in source)
if (predicate(item)) yield return item; // wykonuje faktyczny kod C# na KAŻDYM elemencie
}
// IQueryable.Where przyjmuje DRZEWO WYRAŻEŃ (Expression Tree) - reprezentację STRUKTURY, nie kod
public static IQueryable<T> Where<T>(this IQueryable<T> source, Expression<Func<T, bool>> predicate)
{
// NIE wykonuje predicate! Zamiast tego DOKŁADA je do drzewa Expression,
// które Provider (np. EF Core) przeanalizuje i przetłumaczy na SQL
}
o => o.Status == "Pending" jako Func<Order, bool> to gotowy, skompilowany kod - da się go tylko wykonać, nie da się "zajrzeć do środka" i zobaczyć, co robi. Ten sam kod jako Expression<Func<Order, bool>> to struktura danych opisująca: "porównanie własności Status obiektu z literałem "Pending"" - EF Core czyta tę strukturę i generuje odpowiadający fragment SQL.
Konsekwencja - IQueryable nie akceptuje dowolnego kodu C
// ❌ Rzuci wyjątek w runtime - EF Core nie umie przetłumaczyć DOWOLNEJ metody C# na SQL
var orders = context.Orders.Where(o => IsValidCustomLogic(o)).ToList();
// "The LINQ expression could not be translated"
private bool IsValidCustomLogic(Order o) => /* dowolna złożona logika C# */;
// ✅ Działa - proste wyrażenia, które EF Core UMIE przetłumaczyć na SQL
var orders = context.Orders.Where(o => o.TotalAmount > 100 && o.Status == "Pending").ToList();
To jest ograniczenie, którego nie ma przy IEnumerable - tam każdy kod C#, jakikolwiek by nie był, po prostu się wykonuje, bo to zwykły, skompilowany delegat, a nie struktura do analizy.
Deferred execution (odroczone wykonanie) - wspólna cecha, ale różny "moment" wykonania
// IEnumerable - odracza WYKONANIE KODU C#, ale sama iteracja i tak dzieje się w pamięci
IEnumerable<int> query = numbers.Where(n => n > 5); // NIC się jeszcze nie wykonało
foreach (var n in query) { } // TERAZ faktycznie iteruje i filtruje - ale WCIĄŻ w pamięci .NET
// IQueryable - odracza WYKONANIE ZAPYTANIA (i jego BUDOWĘ jako SQL)
IQueryable<Order> query2 = context.Orders.Where(o => o.Status == "Pending"); // brak SQL
var list = query2.ToList(); // TERAZ generowany SQL I wysyłany do bazy
Kiedy dochodzi do "przejścia" z IQueryable na IEnumerable - materializacja
IQueryable<Order> query = context.Orders.Where(o => o.Status == "Pending"); // wciąż IQueryable, brak SQL
List<Order> materialized = query.ToList(); // .ToList() WYKONUJE zapytanie - wynik to LISTA, konkretne dane w pamięci
// Od TEGO MOMENTU dalsze Where/OrderBy działają JUŻ w pamięci (na List<T>, czyli IEnumerable)
var furtherFiltered = materialized.Where(o => o.TotalAmount > 500); // TO JUŻ nie dotyka bazy - filtr w C#
To jest kluczowy moment "materializacji" - ToList(), ToArray(), First(), Count() wykonują zapytanie SQL i zwracają konkretne dane w pamięci - wszystko, co robisz po tym momencie, to już zwykłe operacje IEnumerable w C#, nie SQL.
Praktyczna reguła - buduj CAŁE zapytanie jako IQueryable, materializuj na końcu
// ✅ Dobra praktyka - WSZYSTKIE warunki dodane, ZANIM wywołasz ToListAsync()
public async Task<List<OrderDto>> SearchOrdersAsync(string status, decimal? minAmount, int page)
{
IQueryable<Order> query = _context.Orders; // zaczynasz jako IQueryable
if (!string.IsNullOrEmpty(status))
query = query.Where(o => o.Status == status); // wciąż IQueryable - dokłada do SQL
if (minAmount.HasValue)
query = query.Where(o => o.TotalAmount >= minAmount); // wciąż IQueryable
query = query.Skip((page - 1) * 20).Take(20); // paginacja TEŻ w SQL (OFFSET/FETCH), nie w pamięci!
return await query.Select(o => new OrderDto(o.Id, o.CustomerName, o.TotalAmount)) // projekcja w SQL
.ToListAsync(); // DOPIERO TERAZ - jedno, kompletne zapytanie SQL z WSZYSTKIMI warunkami
}
To jest dokładnie ten wzorzec paginacji + filtrowania, który powinien zawsze zostać jako IQueryable aż do samego końca - jeśli przedwcześnie zmaterializujesz (ToList() za wcześnie), paginacja (Skip/Take) wykona się w pamięci po pobraniu wszystkich wierszy z bazy, co dla dużej tabeli jest katastrofalne wydajnościowo.
Tabela porównawcza
IEnumerable<T> |
IQueryable<T> |
|
|---|---|---|
Gdzie wykonuje się logika (Where, Select) |
W pamięci, w C# (skompilowany kod) | Tłumaczone na SQL, wykonywane w bazie danych |
Typ parametru w Where/Select |
Func<T, bool> (delegat) |
Expression<Func<T, bool>> (drzewo wyrażeń) |
| Źródło danych | Kolekcje w pamięci (List<T>, tablice) LUB już pobrane dane |
Źródła z providerem LINQ (EF Core, LINQ to SQL) |
| Wydajność przy dużych zbiorach danych | Słaba - trzeba pobrać wszystko do pamięci najpierw | Dobra - filtr/paginacja wykonują się w bazie, przesyłane tylko wynikowe dane |
| Dowolny kod C# w predykacie | ✅ Zawsze działa | ❌ Tylko wyrażenia tłumaczalne na SQL |
| Relacja | Bazowy interfejs | Dziedziczy po IEnumerable<T>, dodaje Expression/Provider |
Podsumowanie - zwięzła odpowiedź na rozmowę
"
IQueryable<T>dziedziczy poIEnumerable<T>, ale reprezentuje zapytanie jako drzewo wyrażeń (Expression), które dopiero przy materializacji (ToList(),ToListAsync()) zostaje przetłumaczone przez providera - w przypadku EF Core na SQL - i wykonane bezpośrednio na bazie danych.IEnumerable<T>operuje na już posiadanych danych w pamięci, wykonując skompilowany kod C# (Func<T,bool>), bez żadnego tłumaczenia. Praktyczna konsekwencja: jeśli w łańcuchu LINQ nadDbSet<T>typ zmienna zostanie w jakimś miejscu zrzutowany naIEnumerable<T>, wszystkie dalsze operacje (Where, paginacja) wykonują się w pamięci PO pobraniu danych z bazy, zamiast być przetłumaczone na SQL - to jest częsty, kosztowny błąd wydajnościowy, więc dobra praktyka to trzymanie typuIQueryable<T>aż do samego końca budowy zapytania, materializując dopiero na sam koniec."