ল্যাঙ্গুয়েজ ইন্টিগ্রেটেড কোয়েরি বা লিংক (LINQ)

var students = new List<(string Name, int Age, double GPA)>
{
    ("Anika",   20, 3.8),
    ("Rafi",     17, 3.2),
    ("Sadia", 22, 3.9),
    ("Tariq",   19, 2.7),
    ("Esha",     21, 3.5)
};

// Method syntax — filter, sort, transform
var honorRoll = students
    .Where(s => s.GPA >= 3.5)        // filter: GPA 3.5+
    .OrderByDescending(s => s.GPA)   // sort: highest first
    .Select(s => $"{s.Name} ({s.GPA})"); // transform: just name + GPA

Console.WriteLine("Honor Roll (method syntax):");
foreach (var entry in honorRoll)
    Console.WriteLine($"  {entry}");

// Query syntax — same result, SQL-like style
var honorRoll2 = from s in students
                 where s.GPA >= 3.5
                 orderby s.GPA descending
                 select $"{s.Name} ({s.GPA})";

Console.WriteLine("\nHonor Roll (query syntax):");
foreach (var entry in honorRoll2)
    Console.WriteLine($"  {entry}");

Honor Roll (method syntax):
  Sadia (3.9)
  Anika (3.8)
  Esha (3.5)

Honor Roll (query syntax):
  Sadia (3.9)
  Anika (3.8)
  Esha (3.5)

var products = new List<(string Name, string Category, decimal Price)>
{
    ("Laptop",      "Electronics", 999.99m),
    ("Mouse",       "Electronics",  29.99m),
    ("Desk",        "Furniture",   249.99m),
    ("Chair",       "Furniture",   399.99m),
    ("Headphones",  "Electronics",  79.99m),
    ("Lamp",        "Furniture",    49.99m)
};

// Any — is there anything expensive?
bool hasExpensive = products.Any(p => p.Price > 500);
Console.WriteLine($"Has expensive items: {hasExpensive}");

// All — is everything under $100?
bool allCheap = products.All(p => p.Price < 100);
Console.WriteLine($"All items under $100: {allCheap}");

// First — get the cheapest item
var cheapest = products.OrderBy(p => p.Price).First();
Console.WriteLine($"Cheapest: {cheapest.Name} at {cheapest.Price:C}");

// Count & Sum
int electronicCount = products.Count(p => p.Category == "Electronics");
decimal totalValue = products.Sum(p => p.Price);
Console.WriteLine($"Electronics: {electronicCount} items");
Console.WriteLine($"Total value: {totalValue:C}");

// GroupBy — group products by category
var groups = products.GroupBy(p => p.Category);
Console.WriteLine("\nBy category:");
foreach (var group in groups)
{
    Console.WriteLine($"  {group.Key}: {group.Count()} items, avg {group.Average(p => p.Price):C}");
}

Has expensive items: True
All items under $100: False
Cheapest: Mouse at $29.99
Electronics: 3 items
Total value: $1,809.94

By category:
  Electronics: 3 items, avg $369.99
  Furniture: 3 items, avg $233.32

var numbers = Enumerable.Range(1, 20).ToList(); // [1, 2, 3, ... 20]

// Chain multiple operations
var result = numbers
    .Where(n => n % 2 == 0)    // evens: 2, 4, 6, 8...
    .Select(n => n * n)         // squared: 4, 16, 36, 64...
    .Where(n => n > 20)         // filter: 36, 64, 100...
    .Take(3);                   // first 3 only

Console.WriteLine($"Chained: [{string.Join(", ", result)}]");

// Pagination with Skip and Take
var page1 = numbers.Skip(0).Take(5);
var page2 = numbers.Skip(5).Take(5);
var page3 = numbers.Skip(10).Take(5);

Console.WriteLine($"Page 1: [{string.Join(", ", page1)}]");
Console.WriteLine($"Page 2: [{string.Join(", ", page2)}]");
Console.WriteLine($"Page 3: [{string.Join(", ", page3)}]");

// Distinct — remove duplicates
var tags = new[] { "csharp", "dotnet", "csharp", "linq", "dotnet", "linq" };
var unique = tags.Distinct().OrderBy(t => t);
Console.WriteLine($"Unique tags: [{string.Join(", ", unique)}]");

// FirstOrDefault — safe first (returns default if empty)
int? firstBig = numbers.Where(n => n > 100).FirstOrDefault();
Console.WriteLine($"First > 100: {firstBig}");  // 0 (default for int)

Chained: [36, 64, 100]
Page 1: [1, 2, 3, 4, 5]
Page 2: [6, 7, 8, 9, 10]
Page 3: [11, 12, 13, 14, 15]
Unique tags: [csharp, dotnet, linq]
First > 100: 0