C# Why does generic IEnumerable inherits non-generic IEnumerable?

Question. Why does generic IEnumerable<T> inherits non-generic IEnumerable?

We have already seen Example of a class that Implements non-generic IEnumerable interface. If look at the definition of generic IEnumerable<T> we get:

namespace System.Collections.Generic
{
    public interface IEnumerable<out T> : IEnumerable
    {
        IEnumerator<T> GetEnumerator();
    }
}

The question is: Why does generic IEnumerable inherits non-generic IEnumerable?

The reason IEnumerable<T> inherits from the non-generic IEnumerable comes down to two major factors in C# history and design: backward compatibility and maximum interoperability. 

Here is a breakdown of why this inheritance is necessary.

1. Backward Compatibility with Legacy Code

Generics were introduced to C# in .NET 2.0 (2005). Before that, .NET 1.0 and 1.1 relied entirely on the non-generic IEnumerable. When generics were added, millions of lines of code already existed that accepted or manipulated the original IEnumerable. 

If IEnumerable<T> did not inherit from IEnumerable, you wouldn't have been able to pass a new generic collection (like List<int>) into an older method designed to accept the legacy interface. By inheriting from IEnumerable, every modern generic collection automatically works with legacy .NET APIs. 

2. Polymorphism (The "Everything is an Object" Rule)

Sometimes, you want to write a method that can process any type of list or collection, regardless of what type of data it holds. Without this inheritance, you would have to write separate overloads for every possible type parameter, or force the method to use reflection. 

Because IEnumerable<out T> inherits from IEnumerable, you can treat any generic collection as a collection of untyped objects:

// This method can accept List<int>, List<string>, Dictionary<k,v>.Values, etc.

public void PrintCollectionCount(IEnumerable collection)

{

    int count = 0;

    foreach (var item in collection) 

    {

        count++;

    }

    Console.WriteLine($"Collection has {count} items.");

}

3. Deep Integration with the foreach Loop

The foreach loop in C# was originally built around the pattern defined by the non-generic IEnumerable. When IEnumerable<T> was introduced, making it inherit from IEnumerable ensured that the C# compiler didn't need to completely rewrite how foreach worked behind the scenes. It allowed the language to gracefully transition into a strongly-typed future without breaking the foundational mechanics of looping.

Why explicit interface implementation for the legacy version?

Because IEnumerable<T> inherits from IEnumerable, any class implementing the generic version must implement both GetEnumerator() methods. To avoid a name clash, C# developers use explicit interface implementation for the legacy version:

public class MyCollection<T> : IEnumerable<T>
{
    // The modern, strongly-typed generic method
    public IEnumerator<T> GetEnumerator()
    {
        // Return your generic enumerator here
    }

    // The legacy non-generic method required by inheritance
    // It hides behind the interface to avoid cluttering your class API
    IEnumerator IEnumerable.GetEnumerator()
    {
        // Simply call the generic version above
        return this.GetEnumerator();
    }
}

Note

• The legacy non generic property and methods are private and explicit interface implementation.
• The generic property and methods are public and implicit interface implementation.
• It is required to implement both generic and non generic interfaces, IEnumerable, IEnumerable<T>, IEnumerator, and IEnumerator<T>.

---