LINQ C#: Where, Select, OrderBy, GroupBy dan Lainnya

LINQ (Language Integrated Query) adalah library berisi method untuk memfilter, mengubah, mengurutkan, mengelompokkan dan merangkum urutan data. Tambahkan using System.Linq; dan setiap array, List<T>, Dictionary serta IEnumerable<T> lainnya mendapat method seperti Where, Select dan OrderBy, yang masing-masing menerima lambda yang menyatakan apa yang harus dilakukan pada satu elemen.

Query pertama: method syntax dan query syntax

LINQ punya dua cara penulisan. Method syntax merangkai pemanggilan; query syntax terbaca seperti SQL. Compiler mengubah query syntax menjadi pemanggilan method yang sama, jadi hasilnya identik.

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));
    }
}

Output:

95, 91, 88
95, 91, 88

Method syntax lebih umum di kode modern, dan sebagian operator (Take, Distinct, Count, First, ToList) hanya ada dalam bentuk method. Query syntax unggul untuk join dan untuk query yang memperkenalkan variabel perantara dengan let. Bagian selanjutnya di halaman ini memakai method syntax dan menunjukkan query syntax saat bentuk itu menambahkan sesuatu.

Where dan Select: memfilter dan memproyeksikan

Where mempertahankan elemen yang cocok dengan sebuah kondisi. Select mengubah setiap elemen menjadi sesuatu yang lain. Bersama-sama, keduanya mencakup sebagian besar query sehari-hari.

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));
    }
}

Output:

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 tidak pernah mengubah elemen, dan Select tidak pernah mengubah jumlahnya. new { p.Name, WithTax = ... } membuat anonymous type, yaitu class yang ditulis compiler untukmu, dan property-nya kamu baca dengan sintaks titik biasa. Tipe ini tidak punya nama yang bisa kamu tulis, jadi variabel yang menyimpannya harus dideklarasikan dengan var, dan tipe ini cocok untuk hasil yang tetap berada di dalam satu method.

OrderBy, ThenBy dan mengurutkan dengan beberapa key

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));
    }
}

Output:

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

OrderBy bersifat stabil: elemen dengan key yang sama tetap dalam urutan aslinya. Pakai ThenBy atau ThenByDescending untuk key kedua. OrderBy kedua akan mengurutkan ulang semuanya berdasarkan key-nya sendiri, sehingga key pertama hanya menjadi penentu saat nilainya sama: prioritas yang terbalik. Di query syntax, key-nya dipisahkan dengan koma: orderby o.Customer, o.Total descending.

Tidak seperti List<T>.Sort, OrderBy tidak mengubah sumbernya dan mengembalikan urutan baru.

First, Single, Last dan versi OrDefault-nya

Method-method ini mengembalikan satu elemen, bukan sebuah urutan. Versi biasanya melempar exception saat tidak ada yang bisa dikembalikan; versi OrDefault mengembalikan nilai default tipe tersebut.

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"
    }
}

Output:

Ana
Ben
Bea
True
First: InvalidOperationException
Single: InvalidOperationException
0

Exception dari First pada urutan kosong adalah InvalidOperationException dengan pesan "Sequence contains no elements" (atau "Sequence contains no matching element" saat predicate tidak cocok dengan apa pun), salah satu error C# yang paling sering dicari. Pakai FirstOrDefault saat "tidak ada" adalah hasil yang wajar, lalu periksa apakah hasilnya null.

Baris terakhir menunjukkan jebakan value type: untuk urutan int, FirstOrDefault mengembalikan 0 saat tidak ada yang cocok, dan itu tidak bisa dibedakan dari 0 yang sungguhan. Filter dengan Where lalu periksa Any() terlebih dahulu, atau di .NET 6 ke atas kirim nilai default-mu sendiri: scores.FirstOrDefault(s => s > 100, -1).

Single dipakai untuk "tepat satu": method ini melempar exception kalau tidak ada elemen atau ada lebih dari satu, sehingga ia berfungsi sebagai pernyataan pemastian sekaligus query.

Any, All, Count dan 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
    }
}

Output:

True
True
True
3
True
True

Any() berhenti di kecocokan pertama, jadi items.Any() adalah cara yang tepat untuk bertanya "apakah ada isinya?". items.Count() > 0 membaca property Count saat sumbernya adalah koleksi seperti list atau array, tapi pada query atau urutan lazy lainnya, ia menelusuri setiap elemen terlebih dahulu. All pada urutan kosong mengembalikan true, karena tidak ada elemen yang gagal memenuhi kondisinya.

Sum, Average, Min dan 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);
        }
    }
}

Output:

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

Sum dari urutan kosong adalah 0, tapi Average, Min dan Max dari urutan angka yang kosong melempar InvalidOperationException: tidak ada jawaban yang masuk akal. Lindungi dengan Any(), atau pakai DefaultIfEmpty() terlebih dahulu: empty.DefaultIfEmpty(0).Average().

Distinct, Take dan 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)));
    }
}

Output:

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 mempertahankan kemunculan pertama setiap nilai sesuai urutannya. Skip(n).Take(m) adalah pola standar untuk pembagian halaman, dan TakeWhile/SkipWhile berhenti atau mulai di elemen pertama yang gagal memenuhi sebuah kondisi. Enumerable.Range(start, count) menghasilkan urutan bilangan bulat tanpa array.

GroupBy

GroupBy memilah elemen ke dalam beberapa wadah berdasarkan sebuah key. Setiap grup punya Key dan juga merupakan sebuah urutan, jadi kamu bisa melakukan agregasi padanya.

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));
    }
}

Output:

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

Grup-grup itu keluar sesuai urutan kemunculan pertama key-nya di sumber (North, South, East), tidak terurut; tambahkan OrderBy(g => g.Key) kalau kamu membutuhkannya. Di query syntax, group X by K memilih apa yang masuk ke setiap grup (di sini hanya nama rep-nya) dan into g memberi nama grup itu supaya query-nya bisa dilanjutkan.

ToList, ToArray dan ToDictionary

Method To... menjalankan query lalu menyimpan hasilnya.

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);
        }
    }
}

Output:

ben@x.com
2
ToDictionary: ArgumentException

ToDictionary melempar ArgumentException saat dua elemen menghasilkan key yang sama, persis seperti Dictionary.Add. Kalau duplikat memang mungkin muncul, kelompokkan terlebih dahulu (seperti yang dilakukan wordCounts) atau pakai ToLookup, yang memetakan setiap key ke sebuah urutan nilai.

Deferred execution

Where, Select, OrderBy, GroupBy dan sebagian besar operator lainnya mengembalikan objek query dan tidak mengerjakan apa pun sampai ada yang mengenumerasinya. Ada dua akibat yang perlu kamu lihat:

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());
    }
}

Output:

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

Query pertama melihat 99 walaupun nilai itu ditambahkan setelah query ditulis: filter-nya berjalan saat string.Join mengenumerasinya. Query kedua mencetak proses konversinya dua kali karena Count() dan Max() masing-masing mengenumerasinya dari awal. Dengan lambda yang ringan, itu hanya pekerjaan yang sia-sia; dengan query database, pembacaan file, atau angka acak di dalam lambda, kedua kali jalan itu bisa mengembalikan data yang berbeda. Saat kamu akan memakai sebuah hasil lebih dari sekali, wujudkan hasilnya dengan ToList() atau ToArray().

Operator yang mengembalikan satu nilai (Count, Sum, First, Any, Max) dan method To... langsung dijalankan. Lihat IEnumerable dan yield untuk cara sifat lazy itu dibangun.

Referensi singkat

Kesalahan yang sering terjadi

• First() pada urutan yang bisa kosong. Melempar "Sequence contains no elements"; pakai FirstOrDefault lalu periksa hasilnya.
• Dua pemanggilan OrderBy. Key kedua menjadi key utama; pakai ThenBy.
• Mengenumerasi sebuah query beberapa kali. Pekerjaannya diulang; panggil ToList() sekali.
• Mengira query menyimpan salinan sumbernya. Query membaca sumbernya saat dienumerasi, bukan saat ditulis.
• Average, Min, Max pada urutan kosong. Ketiganya melempar exception; lindungi dengan Any() atau DefaultIfEmpty.
• Count() > 0 untuk memeriksa apakah ada elemen. Any() berhenti di elemen pertama.