method is delegated to a private collection, list or array's GetEnumerator implementation. public class BankAccount : IEnumerable<decimal> { private List<Tuple<DateTime, decimal>> credits; // assumed all negative private List<Tuple<DateTime, decimal>> debits; // assumed all positive public IEnumerator<decimal> GetEnumerator() { var query = from dc in debits.Union(credits) orderby dc.Item1 /* Date */ select dc.Item2; /* Amount */ foreach (var amount in query) yield return amount; } } // given an instance of BankAccount called ba and a using System.Linq on top of the current file, // one could now write ba.Sum() to get the account balance, ba.Reverse() to see most recent transactions first, // ba.Average() to get the average amount per transaction, etcetera - without ever writing down an arithmetic operator Performance That said, additional implementations of a feature provided by an extension method can be added to improve performance, or to deal with differently implemented interface implementations, such as providing the compiler an implementation of IEnumerable specifically for arrays (in System.SZArrayHelper), which it will automatically choose for extension method calls on array typed references, since their argument will be more specific (this T[] value) than the extension method with the same name that operates on instances of the IEnumerable interface (this IEnumerable value). Alleviating the need for a common base class With generic classes, extension methods allow implementation of behavior that is available for all instantiations of the generic type without requiring them to derive from a common base class, and without restricting the type parameters to a specific inheritance branch. This is a big win, since the situations where this argument holds require a non-generic base class just to implement the shared feature - which then requires the generic subclass to perform boxing and/or casts whenever the type used is one of the type arguments. Conservative use A note should be placed on preferring extension methods over other means of achieving reuse and proper object oriented design. Extension methods might 'clutter' the automatic completion features of code editors, such as Visual Studio's IntelliSense, hence they should either be in their own namespace to allow the developer to selectively import them or they should be defined on a type that is specific enough for the method to appear in IntelliSense only when really relevant and given the above, consider that they might be hard to find should the developer expect them, but miss them from IntelliSense due to a missing using