C# / .NET Kompendium PLEN
.NET / C# / C# — fundamenty języka

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 po IEnumerable<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 nad DbSet<T> typ zmienna zostanie w jakimś miejscu zrzutowany na IEnumerable<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 typu IQueryable<T> aż do samego końca budowy zapytania, materializując dopiero na sam koniec."

Postaw mi kawę