LINQ

Func<int, int> square = x => x * x;
Func<int, int, int> add = (a, b) => a + b;
Action<string> shout = msg => Console.WriteLine(msg.ToUpper() + "!");
Predicate<int> isEven = n => n % 2 == 0;

Console.WriteLine(square(5));
Console.WriteLine(add(2, 3));
shout("hello");
Console.WriteLine(isEven(7));

// a method group works anywhere a matching delegate is expected
Func<string, int> parse = int.Parse;
Console.WriteLine(parse("42") + 1);

Console.WriteLine(Apply(10, square));
Console.WriteLine(Apply(10, n => n - 1));

static int Apply(int value, Func<int, int> f) => f(value);

var counter = MakeCounter();
Console.WriteLine(counter());
Console.WriteLine(counter());
Console.WriteLine(counter());

int threshold = 10;
Func<int, bool> big = n => n > threshold;
threshold = 100;                 // the lambda sees the NEW value
Console.WriteLine(big(50));

static Func<int> MakeCounter()
{
    int count = 0;
    return () => ++count;        // count lives on after MakeCounter returns
}

int[] nums = { 5, 12, 8, 3, 20, 7 };

// query syntax
var q1 = from n in nums
         where n > 6
         orderby n descending
         select n * 10;

// method syntax: what the compiler turns q1 into
var q2 = nums.Where(n => n > 6)
             .OrderByDescending(n => n)
             .Select(n => n * 10);

Console.WriteLine(string.Join(" ", q1));
Console.WriteLine(string.Join(" ", q2));

var products = new List<Product>
{
    new("Laptop", "Tech", 1200m),
    new("Mouse", "Tech", 25m),
    new("Desk", "Home", 300m),
    new("Lamp", "Home", 45m),
    new("Monitor", "Tech", 300m),
};

var affordable = products
    .Where(p => p.Price < 500m)
    .OrderByDescending(p => p.Price)
    .ThenBy(p => p.Name)
    .Select(p => new { p.Name, Label = $"{p.Price:0.00}" });

foreach (var item in affordable)
    Console.WriteLine($"{item.Name,-8} {item.Label}");

var categories = products.Select(p => p.Category).Distinct();
Console.WriteLine(string.Join(", ", categories));

var page2 = products.OrderBy(p => p.Name).Skip(2).Take(2).Select(p => p.Name);
Console.WriteLine(string.Join(", ", page2));

record Product(string Name, string Category, decimal Price);

var orders = new[]
{
    new Order(1, "ana", 40m), new Order(2, "ben", 15m),
    new Order(3, "ana", 60m), new Order(4, "cy", 25m),
    new Order(5, "ben", 35m),
};
var customers = new[]
{
    new Customer("ana", "Lisbon"), new Customer("ben", "Pune"), new Customer("cy", "Oslo"),
};

foreach (var g in orders.GroupBy(o => o.Customer).OrderBy(g => g.Key))
    Console.WriteLine($"{g.Key}: {g.Count()} orders, {g.Sum(o => o.Total)} total");

var withCity = orders.Join(customers,
    o => o.Customer,          // key from the left side
    c => c.Name,              // key from the right side
    (o, c) => $"#{o.Id} {c.City}");
Console.WriteLine(string.Join(" | ", withCity));

Dictionary<string, string> cityOf = customers.ToDictionary(c => c.Name, c => c.City);
Console.WriteLine(cityOf["cy"]);

record Order(int Id, string Customer, decimal Total);
record Customer(string Name, string City);

int[] temps = { 18, 22, 25, 19, 30 };

Console.WriteLine($"avg {temps.Average()}, max {temps.Max()}");
Console.WriteLine(temps.Aggregate((acc, t) => acc * 10 + t % 10));
Console.WriteLine(temps.Aggregate("", (acc, t) => acc + (t > 20 ? "H" : "c")));

Console.WriteLine($"any above 28? {temps.Any(t => t > 28)}");
Console.WriteLine($"all positive? {temps.All(t => t > 0)}");

Console.WriteLine(temps.First(t => t > 20));
Console.WriteLine(temps.FirstOrDefault(t => t > 40));
Console.WriteLine(temps.FirstOrDefault(t => t > 40, -1));
Console.WriteLine(temps.Single(t => t == 25));

var source = new List<int> { 1, 2, 3 };

var query = source.Where(n =>
{
    Console.WriteLine($"  checking {n}");
    return n > 1;
});

Console.WriteLine("query built");
source.Add(4);                        // added AFTER the query was written

Console.WriteLine($"count = {query.Count()}");
Console.WriteLine($"count = {query.Count()}");   // runs the whole thing again

List<int> snapshot = query.ToList();  // runs once more, then stores results
source.Add(5);
Console.WriteLine($"snapshot has {snapshot.Count}");

// File-based apps run the trimming/AOT analyzers; AsQueryable() on an array trips them.
#pragma warning disable IL2026, IL3050
using System.Linq.Expressions;

Func<int, bool> compiled = n => n > 5;
Expression<Func<int, bool>> tree = n => n > 5;

Console.WriteLine(compiled(8));        // runs the code
Console.WriteLine(tree);                // prints the tree, it is data
Console.WriteLine(tree.Body.NodeType);

IQueryable<int> q = new[] { 3, 6, 9 }.AsQueryable().Where(n => n > 5);
Console.WriteLine(q.Expression);
Console.WriteLine(string.Join(",", q));