Is there a good LINQ way to do a cartesian product?

Three-ring circus: from clauses, runtime dynamics and SelectMany mastery

Using static nested 'from' clauses

When dealing with known sets at compile time, using multiple from clauses will visualize the Cartesian product and serve it to you on a silver platter. Let's create a dog show of mixed-breed puppies:

var beagles = new[] { "Napoleon", "Caesar", "Alexander" }; // The formidable conquerors!
var poodles = new[] { "PoodleNap", "PoodleCes", "PoodleXander" }; // The magnificent companions!
// Voila! Behold, the royal parade of mixed-breed pups!
var pairs = from beagle in beagles
            from poodle in poodles
            select new { Beagle = beagle, Poodle = poodle };


Dynamic set generation using CartesianProduct extension

Life's more fun when it's unpredictable, and you don't know your sets until runtime. Here's a CartesianProduct extension method to add to your LINQ utility belt:

public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> sequences)
{
    // Starting with the joke of an empty product...
    IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
    // And boom, you're laughing all the way to your final product!
    return sequences.Aggregate(
        emptyProduct,
        (accumulator, sequence) =>
            from accSeq in accumulator
            from item in sequence
            select accSeq.Concat(new[] { item }));
}
// Fun and dynamic puppy pairings, because who knows what breeds the next litter will bring!
List<List<string>> dogBreeds = new List<List<string>> 
{
    new List<string> { "Beagle", "Pug", "Bulldog" },
    new List<string> { "Poodle", "Dachshund" }
};
var allPossiblePairs = dogBreeds.CartesianProduct();


Deep dive into SelectMany

The SelectMany operator doesn't merely produce Cartesian products. It's a swiss army knife of possibilities - flattening data structures, complex queries, you name it!

Organizing data with ToDictionary and ToLookup

After your data is paired and ready, maybe you want it grouped, for dessert? Try LINQ’s ToDictionary and ToLookup. They can tidy up results into bite-sized pieces:

var puppyPairsAsDictionary = pairs.ToDictionary(
    pair => pair.Beagle, // Beagle is the Key. No key, no entry!
    pair => pair.Poodle); // Poodle is the Value. No value, no point!


LINQ in action: Practical applications

C# goes SQL with LINQ

For those who might miss SQL inside C#, LINQ's from...select syntax allows you to write SQL-like queries in C#.

Complex data structures? No problem!

Hierarchical data? Nested items? LINQ is the bilingual genius that speaks your data's language. Whether your data structure looks like a tree, a graph, or a matryoshka doll, LINQ can handle that!

KeyValuePair: The insurance for your pairs

The KeyValuePair<TKey,TValue> structure in LINQ stores key-value pairs. If you've got a demanding key and an irresistible value, KeyValuePair is your perfect matchmaker!