ToLookup

This returns a data structure that allows indexing. It is an extension method. We get an ILookup instance that can be indexed or enumerated using a foreach-loop.

The entries are combined into groupings at each key. Duplicate keys are allowed—this is an important difference between ToLookup and ToDictionary.

First, this example uses an input string array of 3 string elements. The ToLookup method receives a Func delegate. This is specified as a lambda expression.

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        // Create an array of strings.
        string[] array = { "cat", "dog", "horse" };

        // Generate a lookup structure,
        // ... where the lookup is based on the key length.
        var lookup = array.ToLookup(item => item.Length);

        // Enumerate strings of length 3.
        foreach (string item in lookup[3])
        {
            Console.WriteLine("3 = " + item);
        }

        // Enumerate strings of length 5.
        foreach (string item in lookup[5])
        {
            Console.WriteLine("5 = " + item);
        }

        // Enumerate groupings.
        foreach (var grouping in lookup)
        {
            Console.WriteLine("Grouping:");
            foreach (string item in grouping)
            {
                Console.WriteLine(item);
            }
        }
    }
}
3 = cat
3 = dog
5 = horse
Grouping:
cat
dog
Grouping:
horse

Lambda notes

A lambda expression is a procedure. The formal parameters are specified on the left side of the arrow, while the method body is specified on the right side.

ToDictionary

The Dictionary data structure requires that only one key be associated with one value. The ToLookup data structure, however, allows one key to be associated with multiple values.

We saw the ToLookup extension method in the System.Linq namespace. This method is useful when you want to create a Dictionary-type data structure using LINQ.