C# lambda

LINQ keywords

Keyword Usage
from Starts a query; defines the range variable
where Filters elements (equivalent to .Where())
select Projects the output (equivalent to .Select())
group Groups elements
into Creates a continuation query after select or group
orderby Sorts the results (equivalent to .OrderBy(), .ThenBy())
join Joins two sequences
on Part of the join clause
equals Part of join ... on ... equals ...
let Introduces a new range variable for intermediate values
in Used with from and join to specify the data source
by Used in group and orderby clauses
ascending Sort order (default)
descending Sort order
select Final projection clause
into Continue the query (grouping, etc.)

Core LINQ Method-Syntax

Filtering

Projection

Joining

Sorting

Grouping

Quantifiers

Element Operations

Aggregation

Set Operations

Partitioning

Conversion

Generation

Utility

Opération (FR) Operation (EN) Exemple
Filtrage Filtering Where
Projection Projection Select
Tri Sorting OrderBy
Regroupement Grouping GroupBy
Jointure Join Join
Agrégats Aggregates Sum, Average
Concaténation/Union Concatenation/Union Concat, Union
Quantification Quantifiers Any, All, Contains
Éléments Element methods First, Last, Single
Requête SQL-like Query syntax from ... select ...

Filtrage

LINQ


var numbers = new[] { 1, 2, 3, 4, 5, 6 };
var evens = numbers.Where(n => n % 2 == 0);
foreach (var n in evens)
    Console.WriteLine(n); // 2, 4, 6

SQL-Like


var numbers = new[] { 1, 2, 3, 4, 5 };

var evens = from n in numbers
            where n % 2 == 0
            select n;

foreach (var n in evens)
    Console.WriteLine(n); // 2, 4

Projection

LINQ


var names = new[] { "Jacques", "Marie", "Paul" };
var upper = names.Select(n => n.ToUpper());
foreach (var n in upper)
    Console.WriteLine(n); // JACQUES, MARIE, PAUL

SQL-Like


var people = new[] {
    new { Name = "Jacques", Age = 40 },
    new { Name = "Marie", Age = 25 } };
var names = from p in people
     select p.Name.ToUpper();
foreach (var n in names) 
     Console.WriteLine(n); // JACQUES, MARIE

Tri

LINQ


var people = new[]
{
    new { Name = "Jacques", Age = 40 },
    new { Name = "Marie", Age = 25 },
    new { Name = "Paul", Age = 30 }
};
var sorted = people.OrderBy(p => p.Age);
foreach (var p in sorted)
    Console.WriteLine($"{p.Name} - {p.Age}");

SQL-Like


var people = new[]
{
    new { Name = "Jacques", Age = 40 },
    new { Name = "Marie", Age = 25 },
    new { Name = "Paul", Age = 30 }
};
var sorted = from p in people
             orderby p.Age descending
             select p;
foreach (var p in sorted)
    Console.WriteLine($"{p.Name} - {p.Age}");

Regroupement

LINQ


var words = new[] { "chat", "chien", "cheval", "poule", "poisson" };
var groups = words.GroupBy(w => w[0]); // groupement par première lettre
foreach (var g in groups)
{
    Console.WriteLine($"Lettre {g.Key}:");
    foreach (var w in g)
        Console.WriteLine($"  {w}");
}

SQL-Like


var words = new[] { "chat", "chien", "cheval", "poule", "poisson" };

var groups = from w in words
             group w by w[0] into g
             select new { Lettre = g.Key, Mots = g };

foreach (var g in groups)
{
    Console.WriteLine($"Lettre {g.Lettre}:");
    foreach (var w in g.Mots)
        Console.WriteLine($"  {w}");
}

Jointure

LINQ


var customers = new[]
{
    new { Id = 1, Name = "Jacques" },
    new { Id = 2, Name = "Marie" }
};
var orders = new[]
{
    new { CustomerId = 1, Product = "Laptop" },
    new { CustomerId = 2, Product = "Phone" },
    new { CustomerId = 1, Product = "Tablet" }
};
var query = customers.Join(
    orders,
    c => c.Id,
    o => o.CustomerId,
    (c, o) => new { c.Name, o.Product });
foreach (var item in query)
    Console.WriteLine($"{item.Name} a commandé {item.Product}");

SQL-Like


var customers = new[]
{
    new { Id = 1, Name = "Jacques" },
    new { Id = 2, Name = "Marie" }
};

var orders = new[]
{
    new { CustomerId = 1, Product = "Laptop" },
    new { CustomerId = 2, Product = "Phone" },
    new { CustomerId = 1, Product = "Tablet" }
};

var query = from c in customers
            join o in orders on c.Id equals o.CustomerId
            select new { c.Name, o.Product };

foreach (var item in query)
    Console.WriteLine($"{item.Name} a commandé {item.Product}");

Aggrégation

LINQ


var numbers = new[] { 10, 20, 30, 40 };
Console.WriteLine(numbers.Count());   // 4
Console.WriteLine(numbers.Sum());     // 100
Console.WriteLine(numbers.Average()); // 25
Console.WriteLine(numbers.Min());     // 10
Console.WriteLine(numbers.Max());     // 40

SQL-Like


var numbers = new[] { 10, 20, 30, 40 };

var stats = from n in numbers
            group n by 1 into g
            select new
            {
                Count = g.Count(),
                Sum = g.Sum(),
                Average = g.Average(),
                Min = g.Min(),
                Max = g.Max()
            };

foreach (var s in stats)
    Console.WriteLine($"Count={s.Count}, Sum={s.Sum}, Avg={s.Average}, Min={s.Min}, Max={s.Max}");

Sous-requête

LINQ


var numbers = new[] { 1, 2, 3, 4, 5 };

var query = from n in numbers
            where n > (from m in numbers select m).Average()
            select n;

foreach (var n in query)
    Console.WriteLine(n); // 4, 5

Concaténation - Union

LINQ


var list1 = new[] { 1, 2, 3 };
var list2 = new[] { 3, 4, 5 };
var concat = list1.Concat(list2); // 1,2,3,3,4,5
var union = list1.Union(list2);   // 1,2,3,4,5

Méthodes de quantification (Any, All, Contains)


var numbers = new[] { 1, 2, 3, 4 };
Console.WriteLine(numbers.Any(n => n > 3));   // true
Console.WriteLine(numbers.All(n => n > 0));   // true
Console.WriteLine(numbers.Contains(2));       // true

Méthodes d’éléments (First, Last, Single, ElementAt)


var numbers = new[] { 10, 20, 30 };
Console.WriteLine(numbers.First());       // 10
Console.WriteLine(numbers.Last());        // 30
Console.WriteLine(numbers.Single(n => n == 20)); // 20
Console.WriteLine(numbers.ElementAt(1));  // 20

Syntaxe de requête (style SQL)


var numbers = new[] { 1, 2, 3, 4, 5 };
var query = from n in numbers
            where n % 2 == 0
            orderby n descending
            select n;
foreach (var n in query)
    Console.WriteLine(n); // 4, 2

Core LINQ Method-Syntax

Data

    
var numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var words   = new List<string> { "apple", "banana", "cherry", "date" };

var people = new[]
{
    new { Id = 1, Name = "Alice", Age = 25, Skills = new[]{ "C#", "SQL" } },
    new { Id = 2, Name = "Bob",   Age = 35, Skills = new[]{ "Python", "C++" } },
    new { Id = 3, Name = "Eve",   Age = 28, Skills = new[]{ "Java", "C#" } }
};

Filtering

Where


var result = numbers.Where(n => n > 5);

OfType


IEnumerable<object> mixed = new object[] { 1, "hello", 2.5, "world" };
var result = mixed.OfType<string>();

Projection

Select


var result = numbers.Select(n => n * n);

SelectMany


var result = people.SelectMany(p => p.Skills);

Joining

Join


var ids = new[] { 1, 3 };
var result = people.Join(
    ids,
    p => p.Id,
    id => id,
    (p, id) => p.Name
);

GroupJoin


var result = ids.GroupJoin(
    people,
    id => id,
    p => p.Id,
    (id, group) => new { Id = id, People = group }
);

Zip


var result = numbers.Zip(words, (n, w) => $"{n} - {w}");

Sorting

OrderBy


var result = words.OrderBy(w => w.Length);

OrderByDescending


var result = numbers.OrderByDescending(n => n);

ThenBy


var result = people.OrderBy(p => p.Age).ThenBy(p => p.Name);

ThenByDescending


var result = people.OrderBy(p => p.Age).ThenByDescending(p => p.Name);

Reverse


var result = numbers.Reverse();

Grouping

GroupBy


var result = words.GroupBy(w => w.Length);

ToLookup (like GroupBy but immediate evaluation)


var lookup = words.ToLookup(w => w.Length);

Quantifier

Any


bool hasLarge = numbers.Any(n => n > 8);

All


bool allEven = numbers.All(n => n % 2 == 0);

Contains


bool exists = numbers.Contains(5);

Element Operations

First


var result = numbers.First(n => n > 5);

FirstOrDefault


var result = numbers.FirstOrDefault(n => n > 50);  // returns 0

Single


var result = people.Single(p => p.Id == 1);

Last


var result = words.Last(w => w.StartsWith("c"));

LastOrDefault


var result = words.LastOrDefault(w => w.StartsWith("x"));

ElementAt


var result = numbers.ElementAt(2); // 3

ElementAtOrDefault


var result = numbers.ElementAtOrDefault(20); // 0

DefaultEmpty


var empty = new int[] { };
var result = empty.DefaultIfEmpty(99); // { 99 }

Aggregation

Count


int result = numbers.Count(n => n > 5);

LongCount


long result = numbers.LongCount();

Sum


int result = numbers.Sum();

Min


int result = numbers.Min();

Max


int result = numbers.Max();

Average


double result = numbers.Average();

Aggregate


var result = numbers.Aggregate((acc, n) => acc + n);

Set Operations

Distinct


var result = new[] { 1, 2, 2, 3 }.Distinct();

Union


var result = new[] { 1, 2 }.Union(new[] { 2, 3 });

Intersect


var result = new[] { 1, 2 }.Intersect(new[] { 2, 3 });

Except


var result = new[] { 1, 2, 3 }.Except(new[] { 2 });

Partitioning

Skip


var result = numbers.Skip(3); // skips 1,2,3

SkipWhile


var result = numbers.SkipWhile(n => n < 4);

Take


var result = numbers.Take(3);

TakeWhile


var result = numbers.TakeWhile(n => n < 5);

Conversion

ToArray


var result = numbers.ToArray();

ToList


var result = numbers.ToList();

ToDictionary


var dict = words.ToDictionary(w => w, w => w.Length);

ToHashSet


var result = numbers.ToHashSet();

AsEnumerable


IEnumerable result = numbers.AsEnumerable();

AsQueryable


var query = numbers.AsQueryable();

Cast


IEnumerable<object> obj = numbers.Cast<object>();

Generation

Enumerable.Empty


var empty = Enumerable.Empty<string>();

Enumerable.Repeate


var result = Enumerable.Repeat("A", 3); // A A A

Enumerable.Range


var result = Enumerable.Range(1, 5); // 1..5

Utility

SequenceEqual


bool equal = new[] { 1, 2 }.SequenceEqual(new[] { 1, 2 });

Append


var result = numbers.Append(10);

Prepend


var result = numbers.Prepend(0);

Concat


var result = numbers.Concat(new[] { 10, 11 });