What does the source code for IEnumerable look like?

Question

I'm in the process of learning Interfaces. I've been reading through some books/articles and so far so good - I've written a few sample Interfaces of my own. Yay :)

Now, I've noticed that one of the most popular C# Interfaces around is the IEnumerable Interface. It's used quite a lot for all sorts of collections etc..

Anyway, I'd like to examine it, with intent to further understand how it actually works. I've searched Google but I can't seem to find a reference to the actual source code, but I imagine it would contain the Interface itself, and a class(es) containing the various Methods.

So, is anyone able to help?

Much appreciated

Answer 1

IEnumerable is pretty simple:

[ComVisibleAttribute(True)]
[GuidAttribute("496B0ABE-CDEE-11d3-88E8-00902754C43A")]
public interface IEnumerable
{
    IEnumerator GetEnumerator();
}

And for completeness, IEnumerator

[ComVisibleAttribute(true)]
[GuidAttribute("496B0ABF-CDEE-11d3-88E8-00902754C43A")]
public interface IEnumerator
{
    Object Current {get;}
    bool MoveNext();
    void Reset();
}

But more often what you're really seeing in code samples is IEnumerable<T>

public interface IEnumerable<out T> : IEnumerable
{
    IEnumerator<T> GetEnumerator();
    IEnumerator GetEnumerator(); //inherited from IEnumerable
}

And again for completeness, IEnumerator<T> (with IDisposable):

public interface IEnumerator<out T> : IDisposable, IEnumerator
{

    void Dispose(); //inherited from IDsiposable
    Object Current {get;} //inherited from IEnumerator
    T Current {get;}
    bool MoveNext(); //inherited from IEnumerator
    void Reset(); //inherited from IEnumerator
}

[ComVisibleAttribute(true)]
public interface IDisposable
{
    void Dispose();
}

That's really all there is to it. There is no direct implementation code for any of this that's specific to IEnumerable or the related code show here. Rather, types like arrays or List<T> will inherit from IEnumerable and implement the required methods. Everything else beyond that is done via extension methods.

What makes it all even more powerful are these items:

1. C#'s foreach keyword supports looping over anything that has a GetEnumerator() method that returns an IEnumerator, and therefore you can use any type that implements IEnumerable with a foreach loop.
2. The linq query comprehension syntax works in a similar way, such that you can use most any IEnumerable with linq to objects.
3. The yield keyword allows you to create something called iterator blocks. Iterator blocks have some neat properties (like lazy evaluation) and allow you easily create your own IEnumerable types without having to go to all the trouble of defining a new class first.

Finally, it's worth pointing out here that IDisposable is another interface worth further study, as it is used quite a bit in the framework and has direct language support similar to IEnumerable's foreach with the using keyword.

Answer 2

IEnumerable<T> is merely an interface that defines:

public interface IEnumerable<T> : IEnumerable
{
    // Methods
    IEnumerator<T> GetEnumerator();
}

Most of the methods I assume you want to investigate come from a bunch of extension methods that mainly live in System.Linq namespace in System.Core.dll. Take a look with Reflector.