C# LINQ Tingkat Lanjut 2026: Operator, Performa, dan Pertanyaan Wawancara

Operator LINQ tingkat lanjut membedakan developer .NET berpengalaman dari pemula. Meskipun Where dan Select cukup untuk filtering dasar, proyek nyata membutuhkan penguasaan GroupBy, SelectMany, pola deferred execution, dan komposisi query yang mempertimbangkan performa.

Memahami Deferred Execution dalam LINQ

Query LINQ tidak dieksekusi saat dideklarasikan. Eksekusi terjadi ketika hasil dienumerasi, biasanya melalui foreach, ToList(), atau ToArray(). Perilaku ini, yang disebut deferred execution, memungkinkan komposisi query tanpa pemindaian database atau koleksi berulang.

var numbers = new List<int> { 1, 2, 3, 4, 5 };

// Query didefinisikan tapi tidak dieksekusi
var query = numbers.Where(n => n > 2);

// Menambahkan elemen setelah definisi query
numbers.Add(6);

// Eksekusi terjadi di sini, termasuk 6
foreach (var n in query)
{
    Console.WriteLine(n); // Output: 3, 4, 5, 6
}

Query menangkap referensi ke numbers, bukan isinya. Ketika foreach melakukan iterasi, ia melihat koleksi yang telah diperbarui. Pola ini berguna untuk membangun query dinamis secara bertahap, tetapi menyebabkan bug ketika developer mengharapkan perilaku snapshot.

Untuk memaksa immediate execution, panggil ToList(), ToArray(), atau ToDictionary(). Metode-metode ini mengenumerasi sumber sekali dan menyimpan hasilnya dalam cache.

GroupBy: Lebih dari Pengelompokan Dasar

GroupBy mengubah koleksi datar menjadi struktur hierarkis. Operator ini menerima hingga empat parameter: key selector, element selector, result selector, dan custom comparer.

public record Order(int Id, string Customer, decimal Amount, DateTime Date);

var orders = GetOrders();

// Kelompokkan berdasarkan pelanggan dengan rincian bulanan
var customerMonthlyTotals = orders
    .GroupBy(
        o => new { o.Customer, Month = new DateTime(o.Date.Year, o.Date.Month, 1) },
        (key, group) => new
        {
            key.Customer,
            key.Month,
            Total = group.Sum(o => o.Amount),
            OrderCount = group.Count()
        })
    .OrderBy(x => x.Customer)
    .ThenBy(x => x.Month);

// Output: Pelanggan "Acme" menghabiskan $12,500 di 8 pesanan pada Agustus 2026

Kunci komposit mengelompokkan berdasarkan pelanggan dan bulan. Result selector memproyeksikan langsung ke bentuk yang siap untuk analitik, menghindari pass Select kedua.

SelectMany: Meratakan Koleksi Bersarang

SelectMany meratakan hubungan one-to-many menjadi satu sequence. Operator ini menangani skenario di mana setiap elemen menghasilkan nol atau lebih hasil.

public record Category(string Name, List<Product> Products);
public record Product(string Name, decimal Price);

var categories = GetCategories();

// Ratakan semua produk dengan nama kategorinya
var allProducts = categories
    .SelectMany(
        category => category.Products,
        (category, product) => new
        {
            CategoryName = category.Name,
            ProductName = product.Name,
            product.Price
        });

// Filter setelah diratakan
var expensiveProducts = allProducts
    .Where(p => p.Price > 100)
    .OrderByDescending(p => p.Price);

Overload dua parameter dari SelectMany memberikan akses ke elemen parent dan child, memungkinkan proyeksi yang menggabungkan data dari kedua level. Pola ini menggantikan loop foreach bersarang dengan pendekatan deklaratif.

Sintaks query menawarkan alternatif yang dianggap beberapa developer lebih mudah dibaca untuk join kompleks:

var productsWithCategories =
    from category in categories
    from product in category.Products
    where product.Price > 100
    select new { category.Name, product };

Keduanya dikompilasi ke panggilan SelectMany yang sama. Pilih berdasarkan konvensi tim dan kompleksitas query.

Mengoptimasi Performa LINQ

Abstraksi LINQ memiliki overhead. Setiap operator yang dirantai membuat objek iterator, dan ekspresi lambda menambahkan biaya invokasi delegate. Untuk hot path yang memproses ribuan elemen per detik, biaya-biaya ini terakumulasi.

Menghindari Multiple Enumerations

IEnumerable<Order> GetExpensiveOrders(IEnumerable<Order> orders)
{
    var filtered = orders.Where(o => o.Amount > 1000);
    
    // PERINGATAN: Mengenumerasi dua kali jika orders tidak dimaterialisasi
    if (!filtered.Any())
        return Enumerable.Empty<Order>();
    
    return filtered.OrderBy(o => o.Date);
}

Jika orders berasal dari query database atau file stream, kode ini mengeksekusi sumber dua kali. Materialisasi dengan ToList() sebelum operasi multipel:

IEnumerable<Order> GetExpensiveOrders(IEnumerable<Order> orders)
{
    var filtered = orders.Where(o => o.Amount > 1000).ToList();
    
    if (filtered.Count == 0)
        return Enumerable.Empty<Order>();
    
    return filtered.OrderBy(o => o.Date);
}

Memilih Operator yang Tepat

Beberapa operator LINQ memiliki implementasi yang dioptimasi untuk tipe koleksi tertentu:

Aggregate: Operasi Reduksi Kustom

Aggregate membangun satu hasil dari sequence dengan menerapkan fungsi accumulator. Sementara Sum, Max, dan Average menangani kasus umum, Aggregate memungkinkan reduksi kustom.

var transactions = new List<Transaction>
{
    new("Deposit", 1000),
    new("Withdrawal", -200),
    new("Deposit", 500),
    new("Fee", -25)
};

// Saldo berjalan dengan audit trail
var balanceHistory = transactions.Aggregate(
    new List<(string Op, decimal Balance)>(),
    (history, tx) =>
    {
        var previousBalance = history.Count > 0 ? history[^1].Balance : 0;
        history.Add((tx.Type, previousBalance + tx.Amount));
        return history;
    });

// Output: [(Deposit, 1000), (Withdrawal, 800), (Deposit, 1300), (Fee, 1275)]

Overload tiga parameter menambahkan nilai seed dan result selector akhir, berguna ketika tipe accumulator berbeda dari tipe hasil.

LINQ to Objects vs. LINQ to Entities

Memahami di mana query dieksekusi menentukan karakteristik performanya. LINQ to Objects berjalan di memori dengan delegate C#. LINQ to Entities (EF Core) menerjemahkan ekspresi ke SQL.

using var context = new AppDbContext();

// BURUK: Memuat semua pesanan, filter di memori
var badQuery = context.Orders
    .ToList()
    .Where(o => o.Amount > 1000);

// BAIK: Filter di database, muat hanya baris yang cocok
var goodQuery = context.Orders
    .Where(o => o.Amount > 1000)
    .ToList();

Penempatan ToList() mengubah segalanya. Pada contoh buruk, SQL Server mengembalikan ribuan baris, kemudian C# membuang sebagian besar. Pada contoh baik, klausa WHERE berjalan di sisi server.

Untuk proyeksi kompleks, EF Core 9 (terkini per Agustus 2026) mendukung split queries untuk menghindari ledakan cartesian saat memuat koleksi terkait.

Pertanyaan Wawancara LINQ yang Umum

Wawancara teknis sering menguji pemahaman LINQ melalui pertanyaan konseptual dan live coding. Skenario berikut sering muncul dalam wawancara developer .NET.

"Apa perbedaan antara IEnumerable dan IQueryable?"

IEnumerable<T> bekerja dengan delegate in-memory. Setiap operator yang dirantai membuat iterator yang memproses elemen satu per satu. Runtime tidak dapat mengoptimasi lintas operator.

IQueryable<T> bekerja dengan expression tree. Seluruh query dikompilasi menjadi struktur data yang diterjemahkan provider (EF Core, misalnya) ke SQL. Ini memungkinkan filtering, sorting, dan proyeksi di sisi server.

// Expression tree, diterjemahkan ke klausa SQL WHERE
IQueryable<Order> dbQuery = context.Orders.Where(o => o.Amount > 1000);

// Delegate, dieksekusi di memori C#
IEnumerable<Order> memoryQuery = orders.Where(o => o.Amount > 1000);

Pilih IQueryable saat melakukan query ke sumber data eksternal. Pilih IEnumerable untuk koleksi in-memory atau ketika query harus menggunakan fitur khusus C# seperti regex atau metode kustom.

"Bagaimana cara menemukan duplikat dalam koleksi?"

Pertanyaan coding ini menguji GroupBy dan filtering:

var emails = new[] { "a@test.com", "b@test.com", "a@test.com", "c@test.com" };

var duplicates = emails
    .GroupBy(e => e, StringComparer.OrdinalIgnoreCase)
    .Where(g => g.Count() > 1)
    .Select(g => g.Key);

// Output: ["a@test.com"]

Solusinya mengelompokkan berdasarkan elemen itu sendiri, memfilter grup dengan lebih dari satu anggota, dan memproyeksikan key-nya. Parameter StringComparer.OrdinalIgnoreCase menangani pencocokan email yang tidak case-sensitive.

"Bagaimana cara mengimplementasikan pagination dengan LINQ?"

public IEnumerable<Product> GetProductsPage(int pageNumber, int pageSize)
{
    return context.Products
        .OrderBy(p => p.Id)
        .Skip((pageNumber - 1) * pageSize)
        .Take(pageSize)
        .ToList();
}

Klausa OrderBy wajib untuk pagination yang deterministik. Tanpanya, engine database mungkin mengembalikan baris dalam urutan acak, menyebabkan item muncul di beberapa halaman atau menghilang sama sekali.

Untuk lebih banyak pertanyaan wawancara C#, SharpSkill mencakup fitur-fitur lanjutan termasuk pattern matching, records, dan nullable reference types.

Menulis Query LINQ yang Dapat Dipelihara

Keterbacaan query menurun dengan cepat ketika chain melebihi lima atau enam operator. Ekstrak hasil antara ke variabel bernama, atau pecah logika kompleks ke metode terpisah.

public IEnumerable<CustomerReport> GenerateReports(IEnumerable<Order> orders)
{
    var ordersByCustomer = GroupOrdersByCustomer(orders);
    var reportsWithMetrics = CalculateCustomerMetrics(ordersByCustomer);
    return ApplyBusinessRules(reportsWithMetrics);
}

private IEnumerable<IGrouping<string, Order>> GroupOrdersByCustomer(
    IEnumerable<Order> orders)
{
    return orders
        .Where(o => o.Status == OrderStatus.Completed)
        .GroupBy(o => o.CustomerId);
}

private IEnumerable<CustomerReport> CalculateCustomerMetrics(
    IEnumerable<IGrouping<string, Order>> groups)
{
    return groups.Select(g => new CustomerReport
    {
        CustomerId = g.Key,
        TotalSpent = g.Sum(o => o.Amount),
        OrderCount = g.Count(),
        AverageOrderValue = g.Average(o => o.Amount)
    });
}

Struktur ini membuat setiap transformasi dapat diuji secara terpisah. Nama metode mendokumentasikan maksud lebih baik daripada komentar inline.

Poin-Poin Penting untuk Developer .NET

• Deferred execution menunda evaluasi query hingga enumerasi. Gunakan ToList() atau ToArray() untuk mematerialisasi hasil ketika perilaku snapshot diperlukan atau ketika multiple enumeration akan mengakses sumber data berulang kali.
• GroupBy menyimpan seluruh sumber. Untuk dataset besar, dorong pengelompokan ke database dengan EF Core daripada menarik baris ke memori.
• SelectMany meratakan koleksi bersarang. Overload dua parameter memberikan akses ke elemen parent dan child untuk proyeksi gabungan.
• IQueryable membangun expression tree untuk penerjemahan provider. IEnumerable mengeksekusi delegate di memori. Memilih interface yang salah menyebabkan full table scan.
• Penempatan operator penting untuk performa EF Core. Tempatkan Where, OrderBy, dan Take sebelum ToList() untuk menjalankan filter di sisi server.
• Pertanyaan wawancara sering menguji pemahaman deferred execution, deteksi duplikat dengan GroupBy, dan perbedaan IEnumerable vs. IQueryable.