Uygun Linq nerede hükümler

Günlük hayatımda makul miktarda linq yazıyorum, ama çoğunlukla basit ifadeler. Where cümlelerini kullanırken, onları yazmanın birçok yolu olduğunu ve anlayabildiğim kadarıyla her birinin aynı sonuçlara sahip olduğunu fark ettim. Örneğin;

from x in Collection
  where x.Age == 10
  where x.Name == "Fido"
  where x.Fat == true
  select x;

En azından sonuçlar söz konusu olduğunda buna eşdeğer görünüyor:

from x in Collection
  where x.Age == 10 &&
        x.Name == "Fido" &&
        x.Fat == true
  select x;

Yani gerçekten sözdiziminden başka bir fark var mı? Öyleyse, tercih edilen stil nedir ve neden?

İkincisi, koleksiyondaki her bir öğeye karşı değerlendirmek için yalnızca bir koşula sahip olduğu için daha verimli olacaktır; burada, ilkinde olduğu gibi, ilk koşulu önce tüm öğelere uygular ve sonuç (bu noktada daraltılır) ikinci yüklem için kullanılır vb. Sonuçlar her geçişte daralır, ancak yine de birden fazla geçişi içerir.

Ayrıca zincirleme (ilk yöntem), yalnızca yüklemlerinizi ANDing yapıyorsanız çalışacaktır. Bunun gibi bir şey x.Age == 10 || x.Fat == trueilk yönteminizde işe yaramayacaktır.

DÜZENLEME: LINQ to Objects, beklediğim gibi davranmıyor. Bunun hakkında yazdığım blog yazısı ilginizi çekebilir ...

Ne adlandırılacakları açısından farklıdırlar - ilki şuna eşdeğerdir:

Collection.Where(x => x.Age == 10)
          .Where(x => x.Name == "Fido")
          .Where(x => x.Fat == true)

wheras ikincisi eşdeğerdir:

Collection.Where(x => x.Age == 10 && 
                      x.Name == "Fido" &&
                      x.Fat == true)

Şimdi, gerçekte ne fark yaratan Where, çağrılmanın uygulanmasına bağlıdır . SQL tabanlı bir sağlayıcıysa, ikisinin de aynı SQL'i oluşturmasını beklerdim. LINQ to Objects içindeyse, ikincisi daha az yönlendirme seviyesine sahip olacaktır (dört yerine sadece iki yineleyici dahil olacaktır). Bu dolaylılık seviyelerinin hız açısından önemli olup olmadığı farklı bir konudur.

Tipik olarak where, önemli ölçüde farklı koşulları temsil ettiklerini hissediyorlarsa (örneğin, biri bir nesnenin bir bölümü ile ilgili ve biri tamamen ayrı) birkaç wherecümle ve çeşitli koşullar yakından ilişkili olduğunda (örneğin, belirli bir değer minimumdan büyük ve maksimumdan küçüktür). Temel olarak, herhangi bir küçük performans farkından önce okunabilirliği dikkate almaya değer.

İlki uygulanacak:

Collection.Where(x => x.Age == 10)
          .Where(x => x.Name == "Fido") // applied to the result of the previous
          .Where(x => x.Fat == true)    // applied to the result of the previous

Çok daha basit (ve muhtemelen çok daha hızlı) aksine :

// all in one fell swoop
Collection.Where(x => x.Age == 10 && x.Name == "Fido" && x.Fat == true)

koştuğumda

from c in Customers
where c.CustomerID == 1
where c.CustomerID == 2
where c.CustomerID == 3
select c

ve

from c in Customers
where c.CustomerID == 1 &&
c.CustomerID == 2 &&
c.CustomerID == 3
select c customer table in linqpad

Müşteri tabloma karşı aynı sql sorgusunu çıktı

-- Region Parameters
DECLARE @p0 Int = 1
DECLARE @p1 Int = 2
DECLARE @p2 Int = 3
-- EndRegion
SELECT [t0].[CustomerID], [t0].[CustomerName]
FROM [Customers] AS [t0]
WHERE ([t0].[CustomerID] = @p0) AND ([t0].[CustomerID] = @p1) AND ([t0].[CustomerID] = @p2)

bu yüzden sql'ye çeviride bir fark yoktur ve diğer cevaplarda bunların lambda ifadelerine nasıl dönüştürüleceğini zaten görmüşsünüzdür.

Başlığın altına bakıldığında, iki ifade farklı sorgu temsillerine dönüştürülecektir. Bağlı QueryProviderbir Collectionbu uzak optimize veya olmasın olabilir.

Bu bir linq-to-object çağrısı olduğunda, birden fazla where cümlesi, birbirinden okuyan bir IEnumerables zincirine yol açar. Tek cümleli formu kullanmak burada performansa yardımcı olacaktır.

Temel sağlayıcı bunu bir SQL ifadesine çevirdiğinde, her iki değişkenin de aynı ifadeyi yaratma olasılığı yüksektir.