How can interface IGrouping<out TKey, out TElement> yield multiple values?

Question

I wonder what point I overlook. IGrouping<out TKey, out TElement> is used by LINQ GroupBy. Further, the same logic is applied to ILookup, IIRC. Accordingly, they can return multiple values subject to the key specified. However, instead, I would expect the following signature to be done so.

interface IGrouping<out TKey, out IEnumerable<TElement>>
                                  ^^^^^^^^^^^^^

Originally, it implements IEnumerable<TElement> and IEnumerable for backward compatibility. Does this accomplish the same task? If yes, how? I don't understand.

public interface ILookup<TKey,TElement> : IEnumerable<IGrouping<TKey,TElement>>

Does the followed mean ILookup used by Join/GroupJoin has multiple keys with the association of multiple values? Could you exemplify? I've looked the question, but don't understand the difference, except that their lazy evaluation vs immediate evaluation semantics.

---

Not to do complicate matter further, but the output may help for everyone.

Answer 1

If you look at the declaration of IGrouping,

public interface IGrouping<out TKey,out TElement> : System.Collections.Generic.IEnumerable<out TElement>

You can see that it says "IGrouping<TKey, TElement> is a kind of IEnumerable<TElement>".

It's a special kind of IEnumerable<TElement>. Special in what way? It has a Key associated.

---

And no, this is not valid C# syntax:

interface IGrouping<out TKey, out IEnumerable<TElement>>

Remember that this is an interface declaration, and in the <>, it is declaring the type parameters, which are identifiers, for the interface. IEnumerable<TElement> is not a valid identifier. You also seem to want to refer to the existing interface System.Collections.Generic.IEnumerable<T>, but it makes no sense to put it in this place in the declaration, the same way that it wouldn't make sense to write interface Foo<List<T>> as an interface declaration in Java.

If you mean:

interface IGrouping<out TKey, out TElement> where TElement : IEnumerable

that could work, and there are many ways in which you can design this IGrouping interface. The following way probably makes sense to you the most?

interface IMyGrouping<TKey, TElement> {
    TKey Key { get; }
    IEnumerable<TElement> Elements { get; }
}

But what's really great about .NET framework's design is that it implements an existing interface, and that allows it to be used as an IEnumerable<TElement> directly, which is a very powerful thing. If your class have the ability that the interface promises, implement that interface. See also.

Does the followed mean ILookup used by GroupBy has multiple keys with the association of multiple values?

Yes. Since ILookup implements IEnumerable<IGrouping>, and IGrouping implements IEnumerable, ILookup is kind of like a IEnumerable<IEnumerable> (forgive me using the generics notation very loosely here). So an ILookup an enumerable of enumerables, i.e. like a 2D array. The difference is, that each inner "array" has a Key, since the inner "arrays" are actually IGroupings.