İçeriğe geç
Yazılım ve Teknoloji

IEnumerable, ICollection, IList ve IQueryable farkı

Rıfat Akarca 👁️ 7 okunma 📅 ⏱️ 5 dk okuma
İçindekiler

Bir metodun dönüş tipini yazarken IEnumerable<T>, ICollection<T>, IList<T> ve IQueryable<T> arasında kalmak çok yaygındır. Çoğu zaman hepsi derlenir ve "çalışır", ama seçim API'nizin esnekliğini, sorgu performansını ve veritabanına giden yükü doğrudan etkiler.

Bu yazıda IEnumerable, ICollection, IList ve IQueryable farkını kalıtım zinciri, davranış ve kullanım senaryoları üzerinden ele alıyoruz. Sonunda parametre ve dönüş tiplerini neye göre seçeceğinizi ve EF Core'da en pahalı hatalardan birini nasıl önleyeceğinizi bileceksiniz.

Hiyerarşiye kısa bir bakış

Üç arayüz birbirini genişletir. IList<T>, ICollection<T>'ı; o da IEnumerable<T>'ı genişletir. IQueryable<T> da IEnumerable<T>'dan türer, ama farklı bir yöne gider: veriyi tutmak yerine bir sorguyu temsil eder.

ArayüzEklediği yetenekTipik kullanım
IEnumerable<T>Sırayla gezinme (foreach)Salt okunur tüketim, LINQ to Objects
ICollection<T>Count, Add, Remove, Contains, ClearEleman sayısı ve ekleme/çıkarma gereken yerler
IList<T>İndeksleyici, Insert, RemoveAt, IndexOfSıra ve konuma göre erişim
IQueryable<T>Expression ve ProviderEF Core gibi sağlayıcılara çevrilecek sorgular

IEnumerable<T>: yalnızca gezinme

IEnumerable<T> tek bir şey vaat eder: elemanları baştan sona tek tek verebilirim. Eleman sayısını, indeksle erişimi ya da ekleme yeteneğini garanti etmez. Bu yüzden bir metodun parametresi olarak en esnek seçimdir; liste, dizi, HashSet<T> veya bir yield return üreteci gönderebilirsiniz.

Bu esnekliğin bedeli, arkadaki kaynağın ne olduğunu bilmemenizdir. Elinizdeki şey bellekte hazır bir liste olabileceği gibi, her gezildiğinde yeniden çalışan bir LINQ sorgusu da olabilir. Aynı IEnumerable<T>'ı iki kez gezmek sorguyu iki kez çalıştırabilir. Bu davranışın ayrıntıları için LINQ deferred execution yazısına bakabilirsiniz.

ICollection<T> ve IList<T>: değiştirme ve konuma göre erişim

ICollection<T>, gezinmeye ek olarak Count özelliğini ve değişiklik metotlarını getirir. Elemanları saymak için koleksiyonu baştan sona dolaşmanız gerekmez. EF Core'da navigation property'lerin sıkça ICollection<T> olarak tanımlanmasının sebebi de budur: EF'in ilişkili kayıtları ekleyip çıkarabilmesi gerekir.

IList<T>, bunun üstüne sıra kavramı ekler: list[3] ile erişim, Insert ile araya ekleme, IndexOf ile arama. Sıra ve konum sizin için anlamlı değilse IList<T> istemek gereksiz bir kısıttır.

Diziler IList<T> uygular ama büyüyemez

Diziler IList<T> uygular, fakat boyutları sabittir. Arayüz üzerinden Add çağırırsanız kod derlenir, çalışma zamanında patlar:

IList<int> numbers = new int[] { 1, 2, 3 };

Console.WriteLine(numbers[0]);
numbers.Add(4);

İlk satır sorunsuz çalışır. Add ise NotSupportedException fırlatır, çünkü dizinin IsReadOnly değeri true döner. Arayüzün imzası "ekleyebilirsin" der, somut tip bunu reddeder. Bu yüzden koleksiyonu değiştirmeyecekseniz değiştirme metotları sunan bir arayüz istemek yanıltıcıdır.

IQueryable<T>: veri değil, sorgu

Burada fark sadece "daha fazla metot" değil, çalışma biçiminde ortaya çıkar. IEnumerable<T> üzerindeki Where, bir Func<T, bool> delegesi alır ve elemanları bellekte süzer. IQueryable<T> üzerindeki Where ise bir Expression<Func<T, bool>> alır. Bu ifade ağacı (expression tree) sağlayıcı tarafından, örneğin EF Core tarafından SQL'e çevrilir.

Hangi Where'in seçileceği derleme zamanında değişkenin statik tipine göre belirlenir. Aşağıdaki iki metot aynı işi yapıyor gibi görünür:

public class OrderService(AppDbContext db)
{
    public List<Order> GetBigOrdersWrong()
    {
        IEnumerable<Order> orders = db.Orders;
        return orders.Where(o => o.Total > 1000).ToList();
    }

    public List<Order> GetBigOrders()
    {
        IQueryable<Order> orders = db.Orders;
        return orders.Where(o => o.Total > 1000).ToList();
    }
}

İlk metotta değişken IEnumerable<Order> olduğu için Enumerable.Where seçilir. EF tüm Orders tablosunu getirir, filtre uygulama tarafında çalışır. İkinci metotta filtre SQL'in WHERE koşuluna dönüşür ve veritabanından yalnızca gerekli satırlar gelir. Tablo büyüdükçe fark ağırlaşır.

AsEnumerable tuzağı

Aynı sorun bir zincirin ortasında da çıkar. AsEnumerable() çağrısından sonraki tüm operatörler bellekte çalışır. Bazen bilinçli kullanılır; örneğin SQL'e çevrilemeyen bir C# metodunu çağırmak için. Ama filtreyi bu noktadan önce veritabanına bırakmak gerekir.

Ayrıca bir IQueryable<T> da IEnumerable<T> gibi ertelenmiş çalışır. Sorgu, ToList() ya da foreach gibi bir tetikleyiciye kadar veritabanına gitmez. EF kaynaklı diğer sık hatalar için Entity Framework kullanırken yapılan 7 büyük hata yazısı iyi bir tamamlayıcıdır.

Hangisini ne zaman seçmeli?

Pratik kural şudur: parametrede en geniş, dönüşte kullanıcıya gereken en dar sözleşmeyi seçin.

  • Parametre: Metot yalnızca elemanları dolaşıyorsa IEnumerable<T> isteyin. Çağıran taraf istediği koleksiyonu verebilir.
  • Dönüş, salt okunur liste: Sayı ve indeksli erişim sunacak ama değişikliğe izin vermeyecekseniz IReadOnlyList<T> ya da IReadOnlyCollection<T> kullanın (.NET 4.5'ten beri vardır).
  • Dönüş, değiştirilebilir koleksiyon: Çağıranın ekleme/çıkarma yapması gerçekten isteniyorsa ICollection<T> ya da IList<T> mantıklıdır.
  • IQueryable: Sorgunun veritabanında tamamlanması için yalnızca veri erişim katmanı içinde ya da sorguyu bilerek genişleteceğiniz yerlerde kullanın.

Bu kuralı uygulayan küçük bir örnek:

public record OrderLine(decimal Price, int Quantity);

public class Basket
{
    private readonly List<OrderLine> _lines = [];

    public IReadOnlyList<OrderLine> Lines => _lines.AsReadOnly();

    public void Add(OrderLine line) => _lines.Add(line);

    public static decimal CalculateTotal(IEnumerable<OrderLine> lines) =>
        lines.Sum(l => l.Price * l.Quantity);
}

CalculateTotal yalnızca gezindiği için IEnumerable<OrderLine> ister; dizi, liste ya da sorgu sonucu fark etmez. Lines özelliği ise dış dünyaya sayı ve indeksli erişim verir ama değişiklik yetkisi vermez. Dahili liste, AsReadOnly() ile bir sarmalayıcının arkasında kalır. Salt okunur arayüze doğrudan _lines döndürseydiniz, çağıran taraf onu List<OrderLine>'a cast edip değiştirebilirdi.

IQueryable'ı katman dışına sızdırmak

Repository metotlarından IQueryable<T> döndürmek bir ödünleşimdir (trade-off). Çağıran taraf filtre, sıralama ve sayfalamayı kendisi ekleyebilir; bu esnektir. Ama sorgunun ne zaman ve nasıl çalışacağı, DbContext'in ömrü ve SQL'e çevrilemeyen ifadeler gibi ayrıntılar da katman dışına sızar. Çoğu projede sonucu IReadOnlyList<T> olarak materialize edip döndürmek daha öngörülebilir ve test etmesi daha kolaydır. Katman sınırlarını belirlerken Clean Architecture yazısındaki yaklaşım yol gösterebilir.

Sık Sorulan Sorular

List<T> yerine IList<T> döndürmek her zaman daha mı iyi?

Hayır. Arayüz döndürmek, iç gerçekleştirimi değiştirme özgürlüğü verir, ama çağıranın ihtiyacından geniş bir sözleşme sunuyorsa yanıltıcı olur. Sadece okunacak veri için IReadOnlyList<T>, yalnızca gezinilecekse IEnumerable<T> daha dürüst bir tercihtir.

IEnumerable<T> üzerinde Count() çağırmak pahalı mı?

Kaynağın tipine bağlıdır. Altta ICollection<T> varsa Count() çoğu durumda doğrudan Count değerini kullanır. Ertelenmiş bir LINQ sorgusu ya da yield üreteci ise tüm diziyi gezmek zorunda kalır. Sayıya birden çok kez ihtiyacınız varsa sonucu bir kez materialize edin.

IQueryable<T> ile IEnumerable<T> arasındaki asıl fark nedir?

IEnumerable<T> operatörleri delegelerle belleğte çalıştırır. IQueryable<T> ise ifade ağacı oluşturur ve sağlayıcı bunu, örneğin EF Core ile SQL'e çevirir. Değişkenin statik tipi hangi operatör kümesinin kullanılacağını belirler.

IReadOnlyList<T> gerçekten değişmezlik garantisi verir mi?

Hayır. Arayüz yalnızca okuma metotlarını sunar, ama arkadaki nesne hâlâ değişebilir; çağıran onu somut tipe cast ederse değiştirebilir. Gerçek bir koruma için AsReadOnly() ile sarmalayın ya da değişmez koleksiyonlar kullanın.

Sonuç

IEnumerable, ICollection, IList ve IQueryable farkını üç noktada özetlemek mümkün:

  • Arayüzler yetenek ekler: gezinme, sayı ve değiştirme, indeksli erişim. Parametrede en geniş, dönüşte ihtiyaca yeten en dar olanı seçin.
  • Statik tip operatörü belirler: IEnumerable<T> bellekte, IQueryable<T> sağlayıcıda çalışır. EF sorgusunu erken IEnumerable<T>'a çevirmek tüm tabloyu belleğe taşıyabilir.
  • Dizi bir IList<T>'dır ama büyüyemez; arayüzün sözleşmesi ile somut tipin davranışı her zaman örtüşmez.