Less Known LINQ Methods

Introduction

LINQ extension methods are pretty cool and they make our lives much easier. They are implemented as .NET extension methods over the Enumerable class in the System.Linq namespace and as usual they all apply to IEnumerable<T> sequences.

This time I'll be talking about some LINQ methods that are not so commonly used (as per my understanding). Not sure about you guys, but sometimes I don't even remember that some of these exist.

Aggregate/AggregateBy

Aggregate applies an accumulator function over a sequence, reducing it to a single value. AggregateBy (.NET 9+) does the same but groups by a key first, producing one accumulated result per key.

// Aggregate
var product = new[] { 1, 2, 3, 4 }.Aggregate((acc, x) => acc * x); // 24

// AggregateBy
var words = new[] { "apple", "ant", "bear", "bee" };
var lengthSums = words.AggregateBy(
    keySelector: w => w[0],
    seed: 0,
    func: (acc, w) => acc + w.Length);
// 'a' -> 8, 'b' -> 7

Append/Prepend

Add a single element to the end (Append) or beginning (Prepend) of a sequence without mutating the original.

var numbers = new[] { 2, 3, 4 };
var withEnds = numbers.Prepend(1).Append(5); // 1, 2, 3, 4, 5

Chunk

Chunk splits a sequence into fixed-size arrays (chunks). The last chunk may be smaller.

var chunks = Enumerable.Range(1, 7).Chunk(3);
// [1,2,3], [4,5,6], [7]

CountBy

CountBy counts elements grouped by a key, without allocating full groups (.NET 9+).

var words = new[] { "cat", "car", "dog", "duck", "diver" };
var counts = words.CountBy(w => w[0]); //count grouped by the first letter
// 'c' -> 2, 'd' -> 3

Except/ExceptBy

Except returns elements from the first sequence not present in the second. ExceptBy compares using a key selector instead of the whole element.

var a = new[] { 1, 2, 3, 4 };
var b = new[] { 2, 4 };

var diff = a.Except(b); // 1, 3

var people = new[] { ("Red", 1), ("Green", 2), ("Blue", 3) };
var excludeIds = new[] { 2 };

var filtered = people.ExceptBy(excludeIds, p => p.Item2); // Red, Blue

FullJoin

FullJoin returns all rows from both sequences, matching where keys align and filling with default/null where there's no match on either side (will come in .NET 11+).

var employees = new[] { (Id: 1, Name: "Ana"), (Id: 2, Name: "Ricardo") };
var managers  = new[] { (Id: 2, Manager: "Joao"), (Id: 3, Manager: "Jemma") };

var result = employees.FullJoin(
    managers,
    e => e.Id,
    m => m.Id,
    (e, m) => new { e?.Name, m?.Manager });
// (Ana, null), (Ricardo, Joao), (null, Jemma)

Index

Index pairs each element with its zero-based index, avoiding manual counters (.NET 9+).

foreach (var (index, value) in new[] { "a", "b", "c" }.Index())
{
    Console.WriteLine($"{index}: {value}");
}
// 0: a, 1: b, 2: c

Intersect/IntersectBy

Intersect returns elements present in both sequences. IntersectBy compares by a key instead of the full element.

var a = new[] { 1, 2, 3 };
var b = new[] { 2, 3, 4 };

var common = a.Intersect(b); // 2, 3

var products = new[] { (Id: 1, Name: "A"), (Id: 2, Name: "B") };
var activeIds = new[] { 2 };

var active = products.IntersectBy(activeIds, p => p.Id); // (2, "B")

LeftJoin/RightJoin

LeftJoin keeps every element from the left sequence, pairing with matches from the right (or default if none). RightJoin is the mirror image, keeping every element from the right sequence.

var employees = new[] { (Id: 1, Name: "Ana"), (Id: 2, Name: "Ricardo") };
var managers  = new[] { (Id: 2, Manager: "Jemma") };

var left = employees.LeftJoin(
    managers, e => e.Id, m => m.Id,
    (e, m) => new { e.Name, Manager = m?.Manager });
// (Ana, null), (Ricardo, Jemma)

MaxBy/MinBy

Returns the element with the maximum (MaxBy)/minimum(MinBy) value of a selected key (not the item itself).

var people = new[] { (Name: "Ana", Age: 30), (Name: "Ricardo", Age: 25) };
var youngest = people.MinBy(p => p.Age); // (Ricardo, 25)

Order

Order sorts elements using their natural comparer - shorthand for OrderBy(x => x). Of course, the element itself must be comparable! You can also provide your own comparer (IComparer<T>).

var sorted = new[] { 3, 1, 2 }.Order(); // 1, 2, 3

SkipWhile

SkipWhile skips elements from the start as long as a condition is true, then returns the rest (even if the condition becomes true again later).

var numbers = new[] { 1, 2, 3, 4, 1 };
var result = numbers.SkipWhile(n => n < 3); // 3, 4, 1

TakeLast

TakeLast returns the last N elements of a sequence.

var lastTwo = new[] { 1, 2, 3, 4, 5 }.TakeLast(2); // 4, 5

TakeWhile

TakeWhile takes elements from the start as long as a condition is true, stopping at the first failure.

var numbers = new[] { 1, 2, 3, 4, 1 };
var result = numbers.TakeWhile(n => n < 3); // 1, 2

ToLookup

ToLookup builds an immutable, multi-value dictionary-like ILookup<K, V> structure (a key can map to multiple values), evaluated immediately.

var words = new[] { "apple", "ant", "bear", "bee" };
var lookup = words.ToLookup(w => w[0]);

foreach (var w in lookup['a'])
{
  Console.WriteLine(w); // apple, ant
}

Union/UnionBy

Union returns distinct elements from both sequences combined. UnionBy deduplicates using a key selector.

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

var combined = a.Union(b); // 1, 2, 3, 4, 5

var people = new[] { (Id: 1, Name: "Ana") };
var more   = new[] { (Id: 1, Name: "Ana"), (Id: 2, Name: "Ricardo") };

var uniquePeople = people.UnionBy(more, p => p.Id);
// (1, Ana), (2, Ricardo) — first occurrence wins

Zip

Zip combines two (or three) sequences element-by-element into tuples or a projection, stopping at the shortest sequence.

var names = new[] { "Ana", "Ricardo" };
var ages  = new[] { 30, 25 };

var zipped = names.Zip(ages, (n, a) => $"{n} is {a}");
// "Ana is 30", "Ricardo is 25"

Conclusion

As always, I hope you find this useful: a few less-known extension methods with a simple example for each. Give me a shout if you feel anything is missing!

Location: Coimbra, Portugal

Comments

Post a Comment

Popular posts from this blog

Modern Mapping with EF Core

Image
Introduction In EF Core (as in most O/RMs) we can map and store multiple things: Objects that hold a single value, like int , string , bool , float , Guid , DateTime , TimeSpan , Uri , etc. These are (somewhat wrongly) called primitive types  and are always included inside some container, like the following Objects that hold multiple single values and which have an identity, for example, Customer , Product , Order . These are called entity types  and they must have an identity that makes them unique amongst all the other objects of the same type Objects that are structured to hold multiple values, but have no identity, such as Address , Coordinate . These are called value types  and are merely a collection of (possibly related) properties We can also have collections of the previous things There's more to it, of course, for example, it is even possible to represent  inheritance of entities , of which I talked about before , In this post I am going to cover so...
Read more

OpenTelemetry with ASP.NET Core

Image
Introduction I wrote a post not too long ago about the building blocks of telemetry , or distributed tracing , with ASP.NET Core. Now I'm going to talk about how we can see it working using an open source bundle, otel-lgtm . Mind you, this may not be 100% suitable for production, but for development purposes, it should be fine, all concepts apply, of course. I won't cover everything about OpenTelemetry here, but should hopefully give you some insights as to what's there and how you can make good use of it. First, lets see what some of the concepts are. If you're interested in learning more about metrics, I suggest having a look at my post on this topic . OpenTelemetry OpenTelemetry  (OTel) provides a single, open-source standard, and a set of technologies to capture and export metrics, traces, and logs from your cloud-native applications and infrastructure. OTel is both a standard and a reference implementation that builds on other standards, such as W3C Distributed Tr...
Read more

.NET 10 Validation

Note: this is an update to my original post . Introduction I wrote about  entity validation  in the past, the reason I'm coming back to it is that there are some changes in .NET 10, related to validation. Let's cover the original validation API and then explain what has changed. .NET Validation Validation is implemented in the System.ComponentModel.DataAnnotations namespace. I'll describe it first and then move to the small changes in .NET 10. .NET has featured a way to validate classes and their properties for a long time, the API is called  Data Annotations Validation , and it integrates nicely with ASP.NET Core MVC and other frameworks (not Entity Framework Core, as  I've talked recently , nor ASP.NET Core Minimal APIs ). It is essentially, but not just, based on a set of attributes, one interface, and a class that performs validations on a target class and its properties, from the validation attributes it contain. The base class for attribute validation is ca...
Read more