C# LINQ: Where, Select, OrderBy, GroupBy ve Fazlası

LINQ (Language Integrated Query), dizileri filtrelemek, dönüştürmek, sıralamak, gruplamak ve özetlemek için bir metot kütüphanesidir. using System.Linq; ekleyin; her dizi, List<T>, Dictionary ve diğer IEnumerable<T>, her biri tek bir elemanla ne yapılacağını söyleyen bir lambda alan Where, Select ve OrderBy gibi metotlar kazanır.

İlk sorgu: metot sözdizimi ve sorgu sözdizimi

LINQ'in iki gösterimi vardır. Metot sözdizimi çağrıları zincirler; sorgu sözdizimi SQL gibi okunur. Derleyici sorgu sözdizimini aynı metot çağrılarına çevirir, bu yüzden aynı sonuçları üretirler.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] scores = { 72, 95, 60, 88, 79, 91 };

        // Method syntax
        IEnumerable<int> high = scores
            .Where(s => s >= 80)
            .OrderByDescending(s => s);

        // Query syntax: the same query
        IEnumerable<int> high2 =
            from s in scores
            where s >= 80
            orderby s descending
            select s;

        Console.WriteLine(string.Join(", ", high));
        Console.WriteLine(string.Join(", ", high2));
    }
}

Çıktı:

95, 91, 88
95, 91, 88

Modern kodda metot sözdizimi daha yaygındır ve bazı operatörler (Take, Distinct, Count, First, ToList) yalnızca metot olarak vardır. Sorgu sözdizimi join'lerde ve let ile ara değişkenler tanıtan sorgularda parlar. Bu sayfanın geri kalanı metot sözdizimini kullanır ve bir şey kattığı yerde sorgu sözdizimini gösterir.

Where ve Select: filtrelemek ve projeksiyon

Where bir koşulu karşılayan elemanları tutar. Select her elemanı başka bir şeye dönüştürür. Birlikte günlük sorguların çoğunu karşılarlar.

using System;
using System.Collections.Generic;
using System.Linq;

class Product
{
    public string Name;
    public string Category;
    public decimal Price;
    public Product(string n, string c, decimal p) { Name = n; Category = c; Price = p; }
}

class Program
{
    static void Main()
    {
        var products = new List<Product>
        {
            new Product("Mug", "Kitchen", 8.50m),
            new Product("Lamp", "Home", 32.00m),
            new Product("Kettle", "Kitchen", 27.00m),
            new Product("Rug", "Home", 120.00m),
        };

        IEnumerable<string> cheapNames = products
            .Where(p => p.Price < 30m)
            .Select(p => p.Name);
        Console.WriteLine(string.Join(", ", cheapNames));

        var labels = products.Select(p => p.Name.ToUpper() + " $" + p.Price);
        Console.WriteLine(string.Join(" | ", labels));

        // An anonymous type holds a few properties without declaring a class.
        var summary = products
            .Where(p => p.Category == "Home")
            .Select(p => new { p.Name, WithTax = Math.Round(p.Price * 1.2m, 2) });
        foreach (var item in summary)
        {
            Console.WriteLine(item.Name + ": " + item.WithTax);
        }

        // Select also has an overload with the index.
        var numbered = products.Select((p, i) => (i + 1) + ". " + p.Name);
        Console.WriteLine(string.Join(" ", numbered));
    }
}

Çıktı:

Mug, Kettle
MUG $8.50 | LAMP $32.00 | KETTLE $27.00 | RUG $120.00
Lamp: 38.40
Rug: 144.00
1. Mug 2. Lamp 3. Kettle 4. Rug

Where elemanları asla değiştirmez, Select de kaç tane olduklarını asla değiştirmez. new { p.Name, WithTax = ... } anonim bir tip oluşturur: derleyicinin sizin için yazdığı, property'lerini normal nokta sözdizimiyle okuduğunuz bir sınıf. Yazabileceğiniz bir adı yoktur, bu yüzden birini tutan bir değişken var ile bildirilmelidir ve tek bir metodun içinde kalan sonuçlara uyar.

OrderBy, ThenBy ve birkaç anahtara göre sıralama

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var orders = new List<(string Customer, decimal Total)>
        {
            ("Ben", 40m), ("Ana", 15m), ("Ben", 90m), ("Ana", 60m), ("Chloe", 25m),
        };

        var sorted = orders
            .OrderBy(o => o.Customer)            // first key
            .ThenByDescending(o => o.Total);     // tie breaker
        foreach (var o in sorted)
        {
            Console.WriteLine(o.Customer + " " + o.Total);
        }

        var query =
            from o in orders
            orderby o.Total descending
            select o.Customer;
        Console.WriteLine(string.Join(", ", query));
    }
}

Çıktı:

Ana 60
Ana 15
Ben 90
Ben 40
Chloe 25
Ben, Ana, Ben, Chloe, Ana

OrderBy kararlıdır: anahtarları eşit olan elemanlar orijinal sıralarında kalır. İkinci bir anahtar için ThenBy ya da ThenByDescending kullanın. İkinci bir OrderBy her şeyi kendi anahtarına göre yeniden sıralar ve ilk anahtarı yalnızca eşitlik bozucu olarak bırakır: ters öncelik. Sorgu sözdiziminde anahtarlar virgülle ayrılır: orderby o.Customer, o.Total descending.

List<T>.Sort'un aksine OrderBy kaynağa dokunmaz ve yeni bir dizi döndürür.

First, Single, Last ve OrDefault sürümleri

Bunlar bir dizi yerine tek bir eleman döndürür. Düz sürümler döndürecek bir şey olmadığında istisna fırlatır; OrDefault sürümleri tipin varsayılan değerini döndürür.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var names = new List<string> { "Ana", "Ben", "Bea", "Chloe" };

        Console.WriteLine(names.First());
        Console.WriteLine(names.First(n => n.StartsWith("B")));
        Console.WriteLine(names.Last(n => n.StartsWith("B")));
        Console.WriteLine(names.FirstOrDefault(n => n.StartsWith("Z")) == null);

        try
        {
            names.First(n => n.StartsWith("Z"));
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine("First: " + e.GetType().Name);
        }

        try
        {
            names.Single(n => n.StartsWith("B")); // two matches
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine("Single: " + e.GetType().Name);
        }

        int[] scores = { 72, 95 };
        Console.WriteLine(scores.FirstOrDefault(s => s > 100)); // 0, not "missing"
    }
}

Çıktı:

Ana
Ben
Bea
True
First: InvalidOperationException
Single: InvalidOperationException
0

Boş bir dizide First'ten gelen istisna, "Sequence contains no elements" (ya da bir koşul hiçbir şeyle eşleşmediğinde "Sequence contains no matching element") mesajlı InvalidOperationException'dır; en çok aranan C# hatalarından biridir. "Hiç yok" normal bir sonuçsa FirstOrDefault kullanın ve null için kontrol edin.

Son satır değer tipi tuzağını gösterir: bir int dizisi için FirstOrDefault hiçbir şey eşleşmediğinde 0 döndürür ve bu gerçek bir 0'dan ayırt edilemez. Where ile filtreleyip önce Any() kontrol edin ya da .NET 6 ve sonrasında kendi varsayılanınızı verin: scores.FirstOrDefault(s => s > 100, -1).

Single "tam olarak bir" içindir: hiç yoksa ya da birden fazlaysa istisna fırlatır; bu da onu bir sorgu kadar bir doğrulama yapar.

Any, All, Count ve Contains

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] ages = { 17, 22, 35, 41, 16 };

        Console.WriteLine(ages.Any());                 // is it non-empty?
        Console.WriteLine(ages.Any(a => a < 18));      // at least one minor?
        Console.WriteLine(ages.All(a => a >= 16));     // everyone 16 or older?
        Console.WriteLine(ages.Count(a => a >= 18));   // how many adults?
        Console.WriteLine(ages.Contains(35));

        int[] none = { };
        Console.WriteLine(none.All(a => a > 100));      // true for an empty sequence
    }
}

Çıktı:

True
True
True
3
True
True

Any() ilk eşleşmede durur, bu yüzden "bir şey var mı?" diye sormanın doğru yolu items.Any()'dir. Kaynak bir liste ya da dizi gibi bir koleksiyonsa items.Count() > 0 Count property'sini okur, ama bir sorguda ya da başka tembel bir dizide önce her elemanı dolaşır. Boş bir dizide All true döndürür, çünkü koşulu sağlamayan bir eleman yoktur.

Sum, Average, Min ve Max

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var cart = new List<(string Item, decimal Price, int Qty)>
        {
            ("Tea", 4.50m, 2), ("Honey", 7.25m, 1), ("Cups", 3.00m, 4),
        };

        Console.WriteLine("Total: " + cart.Sum(c => c.Price * c.Qty));
        Console.WriteLine("Items: " + cart.Sum(c => c.Qty));
        Console.WriteLine("Priciest: " + cart.Max(c => c.Price));
        Console.WriteLine("Average price: " + cart.Average(c => c.Price).ToString("F2"));

        var empty = new List<int>();
        Console.WriteLine(empty.Sum());
        try
        {
            empty.Average();
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine("Average: " + e.GetType().Name);
        }
    }
}

Çıktı:

Total: 28.25
Items: 7
Priciest: 7.25
Average price: 4.92
0
Average: InvalidOperationException

Boş bir dizinin Sum'ı 0'dır, ama boş bir sayı dizisinin Average, Min ve Max'i InvalidOperationException fırlatır: mantıklı bir cevap yoktur. Any() ile koruyun ya da önce DefaultIfEmpty() kullanın: empty.DefaultIfEmpty(0).Average().

Distinct, Take ve Skip

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string[] visits = { "home", "shop", "home", "cart", "shop", "home" };
        Console.WriteLine(string.Join(", ", visits.Distinct()));

        int[] ids = Enumerable.Range(1, 23).ToArray(); // 1..23
        int pageSize = 10;
        for (int page = 0; page * pageSize < ids.Length; page++)
        {
            var items = ids.Skip(page * pageSize).Take(pageSize);
            Console.WriteLine("Page " + (page + 1) + ": " + string.Join(" ", items));
        }

        int[] temps = { 12, 15, 21, 24, 19, 11 };
        Console.WriteLine(string.Join(", ", temps.TakeWhile(t => t < 20)));
    }
}

Çıktı:

home, shop, cart
Page 1: 1 2 3 4 5 6 7 8 9 10
Page 2: 11 12 13 14 15 16 17 18 19 20
Page 3: 21 22 23
12, 15

Distinct her değerin ilk geçişini sırayla tutar. Skip(n).Take(m) standart sayfalama kalıbıdır ve TakeWhile/SkipWhile bir koşulu sağlamayan ilk elemanda durur ya da başlar. Enumerable.Range(start, count) dizi olmadan bir tamsayı dizisi üretir.

GroupBy

GroupBy elemanları bir anahtara göre kovalara ayırır. Her grubun bir Key'i vardır ve kendisi bir dizidir, bu yüzden onu toplayabilirsiniz.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var sales = new List<(string Region, string Rep, int Amount)>
        {
            ("North", "Ana", 300), ("South", "Ben", 150), ("North", "Chloe", 200),
            ("East", "Dev", 350), ("South", "Eli", 250), ("North", "Ana", 100),
        };

        foreach (var g in sales.GroupBy(s => s.Region))
        {
            Console.WriteLine(g.Key + ": " + g.Count() + " sales, total " + g.Sum(s => s.Amount));
        }

        var top = sales
            .GroupBy(s => s.Rep)
            .Select(g => new { Rep = g.Key, Total = g.Sum(s => s.Amount) })
            .OrderByDescending(x => x.Total)
            .First();
        Console.WriteLine("Top rep: " + top.Rep + " " + top.Total);

        var byRegion =
            from s in sales
            group s.Rep by s.Region into g
            select g.Key + " -> " + string.Join("/", g);
        Console.WriteLine(string.Join("; ", byRegion));
    }
}

Çıktı:

North: 3 sales, total 600
South: 2 sales, total 400
East: 1 sales, total 350
Top rep: Ana 400
North -> Ana/Chloe/Ana; South -> Ben/Eli; East -> Dev

Gruplar sıralı değil, anahtarlarının kaynakta ilk göründüğü sırayla çıkar (North, South, East); bunu istiyorsanız OrderBy(g => g.Key) ekleyin. Sorgu sözdiziminde group X by K her gruba neyin gireceğini seçer (burada yalnızca temsilcinin adı) ve into g sorgunun devam edebilmesi için gruba ad verir.

ToList, ToArray ve ToDictionary

To... metotları sorguyu çalıştırır ve sonuçları saklar.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var users = new List<(int Id, string Email)>
        {
            (1, "ana@x.com"), (2, "ben@x.com"), (3, "cy@x.com"),
        };

        Dictionary<int, string> byId = users.ToDictionary(u => u.Id, u => u.Email);
        Console.WriteLine(byId[2]);

        var wordCounts = "to be or not to be".Split(' ')
            .GroupBy(w => w)
            .ToDictionary(g => g.Key, g => g.Count());
        Console.WriteLine(wordCounts["be"]);

        try
        {
            users.ToDictionary(u => u.Email.Length); // two emails of length 9
        }
        catch (ArgumentException e)
        {
            Console.WriteLine("ToDictionary: " + e.GetType().Name);
        }
    }
}

Çıktı:

ben@x.com
2
ToDictionary: ArgumentException

İki eleman aynı anahtarı ürettiğinde ToDictionary, tıpkı Dictionary.Add gibi ArgumentException fırlatır. Tekrarlar bekleniyorsa önce gruplayın (wordCounts'un yaptığı gibi) ya da her anahtarı bir değerler dizisine eşleyen ToLookup'ı kullanın.

Ertelenmiş yürütme

Where, Select, OrderBy, GroupBy ve diğer operatörlerin çoğu bir sorgu nesnesi döndürür ve bir şey onu dolaşana kadar hiçbir iş yapmaz. Bunun görmeye değer iki sonucu vardır:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var prices = new List<int> { 10, 25, 40 };

        IEnumerable<int> expensive = prices.Where(p => p > 20); // nothing runs yet
        prices.Add(99);                                        // added after the query
        Console.WriteLine(string.Join(", ", expensive));        // runs now, sees 99

        IEnumerable<int> logged = prices.Select(p =>
        {
            Console.WriteLine("  converting " + p);
            return p * 100;
        });

        Console.WriteLine("Count: " + logged.Count());          // runs the query once
        Console.WriteLine("Max: " + logged.Max());              // and again

        List<int> cached = logged.ToList();                     // run once, keep results
        Console.WriteLine("Cached: " + cached.Count + ", " + cached.Max());
    }
}

Çıktı:

25, 40, 99
  converting 10
  converting 25
  converting 40
  converting 99
Count: 4
  converting 10
  converting 25
  converting 40
  converting 99
Max: 9900
  converting 10
  converting 25
  converting 40
  converting 99
Cached: 4, 9900

İlk sorgu, sorgu yazıldıktan sonra eklendiği halde 99'u gördü: filtre string.Join onu dolaştığında çalıştı. İkinci sorgu dönüşümlerini iki kez yazdırdı, çünkü Count() ve Max() onu her biri sıfırdan dolaştı. Ucuz bir lambda ile bu yalnızca boşa harcanan iştir; lambda'nın içinde bir veritabanı sorgusu, bir dosya okuma ya da rastgele bir sayı olduğunda iki geçiş farklı veri döndürebilir. Bir sonucu birden fazla kez kullanacaksanız onu ToList() ya da ToArray() ile somutlaştırın.

Tek bir değer döndüren operatörler (Count, Sum, First, Any, Max) ve To... metotları hemen çalışır. Bu tembelliğin nasıl kurulduğu için IEnumerable ve yield sayfasına bakın.

Hızlı başvuru

Yaygın hatalar

• Boş olabilecek bir dizide First(). "Sequence contains no elements" fırlatır; FirstOrDefault kullanın ve kontrol edin.
• İki OrderBy çağrısı. İkinci anahtar asıl anahtar olur; ThenBy kullanın.
• Bir sorguyu birkaç kez dolaşmak. İş tekrarlanır; bir kez ToList() çağırın.
• Bir sorgunun kaynağının anlık görüntüsünü almasını beklemek. Kaynağı yazıldığında değil, dolaşıldığında okur.
• Boş bir dizide Average, Min, Max. İstisna fırlatırlar; Any() ya da DefaultIfEmpty ile koruyun.
• Eleman olup olmadığını test etmek için Count() > 0. Any() ilkinde durur.