Return to Answer

public static partial class EnumerableEx
{
    public static IEnumerable<IGrouping<TKey, TSource>> GroupByConsecutive<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
    {
        return GroupByConsecutive(source, keySelector, null as IEqualityComparer<TKey>);
    }

    public static IEnumerable<IGrouping<TKey, TSource>> GroupByConsecutive<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer)
    {
        return GroupByConsecutive(source, keySelector, Functions.Identity<TSource>, keyComparer);
    }

    public static IEnumerable<IGrouping<TKey, TElement>> GroupByConsecutive<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
    {
        return GroupByConsecutive(source, keySelector, elementSelector, null as IEqualityComparer<TKey>);
    }

    public static IEnumerable<IGrouping<TKey, TElement>> GroupByConsecutive<TSource, TKey, TElement>(
        this IEnumerable<TSource> source,
        Func<TSource, TKey> keySelector,
        Func<TSource, TElement> elementSelector,
        IEqualityComparer<TKey> keyComparer)
    {
        return ConsecutiveGrouper<TKey, TElement>.Create(source, keySelector, elementSelector, keyComparer as IEqualityComparer<TKey>);
    }

    internal class ConsecutiveGrouper<TKey, TElement> : IEnumerable<IGrouping<TKey, TElement>>
    {
        internal static ConsecutiveGrouper<TKey, TElement> Create<TSource, TKey, TElement>(
            IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            Func<TSource, TElement> elementSelector,
            IEqualityComparer<TKey> keyComparer)
        {
            source.ThrowIfNull("source");
            keySelector.ThrowIfNull("keySelector");
            elementSelector.ThrowIfNull("elementSelector");

            var grouper = new ConsecutiveGrouper<TKey, TElement>(keyComparer);
            foreach (var item in source)
            {
                grouper.NextGroup(keySelector(item)).Add(elementSelector(item));
            }
            return grouper;
        }

        private ConsecutiveGrouper(IEqualityComparer<TKey> keyComparer)
        {
            this._keyComparer = keyComparer ?? EqualityComparer<TKey>.Default;
            this._groupings = new List<Grouping>();
        }
        private IEqualityComparer<TKey> _keyComparer;
        private List<Grouping> _groupings;
 
        private Grouping NextGroup(TKey key)
        {
            Grouping grouping;

            if (_groupings.Count == 0)
            {
                grouping = new Grouping(key);
                _groupings.Add(grouping);
            }
            else
            {
                grouping = _groupings[_groupings.Count - 1];
                if (!_keyComparer.Equals(grouping.Key, key))
                {
                    grouping = new Grouping(key);
                    _groupings.Add(grouping);
                }
            }
            return grouping;
        }

        public IEnumerator<IGrouping<TKey, TElement>> GetEnumerator()
        {
            return _groupings.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        class Grouping : IGrouping<TKey, TElement>
        {
            internal Grouping(TKey key)
            {
                this.Key = key;
                this._elements = new List<TElement>();
            }
            public TKey Key { get; private set; }
            private List<TElement> _elements;

            internal void Add(TElement element)
            {
                _elements.Add(element);
            }

            public IEnumerator<TElement> GetEnumerator()
            {
                return _elements.GetEnumerator();
            }

            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }
    }
}

public static partial class EnumerableEx
{
    public static IEnumerable<IGrouping<TKey, TSource>> GroupByConsecutive<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
    {
        return GroupByConsecutive(source, keySelector, null as IEqualityComparer<TKey>);
    }

    public static IEnumerable<IGrouping<TKey, TSource>> GroupByConsecutive<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer)
    {
        return GroupByConsecutive(source, keySelector, Functions.Identity<TSource>, keyComparer);
    }

    public static IEnumerable<IGrouping<TKey, TElement>> GroupByConsecutive<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
    {
        return GroupByConsecutive(source, keySelector, elementSelector, null as IEqualityComparer<TKey>);
    }

    public static IEnumerable<IGrouping<TKey, TElement>> GroupByConsecutive<TSource, TKey, TElement>(
        this IEnumerable<TSource> source,
        Func<TSource, TKey> keySelector,
        Func<TSource, TElement> elementSelector,
        IEqualityComparer<TKey> keyComparer)
    {
        return ConsecutiveGrouper<TKey, TElement>.Create(source, keySelector, elementSelector, keyComparer as IEqualityComparer<TKey>);
    }

    internal class ConsecutiveGrouper<TKey, TElement> : IEnumerable<IGrouping<TKey, TElement>>
    {
        internal static ConsecutiveGrouper<TKey, TElement> Create<TSource, TKey, TElement>(
            IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            Func<TSource, TElement> elementSelector,
            IEqualityComparer<TKey> keyComparer)
        {
            source.ThrowIfNull("source");
            keySelector.ThrowIfNull("keySelector");
            elementSelector.ThrowIfNull("elementSelector");

            var grouper = new ConsecutiveGrouper<TKey, TElement>(keyComparer);
            foreach (var item in source)
            {
                grouper.NextGroup(keySelector(item)).Add(elementSelector(item));
            }
            return grouper;
        }

        private ConsecutiveGrouper(IEqualityComparer<TKey> keyComparer)
        {
            this._keyComparer = keyComparer ?? EqualityComparer<TKey>.Default;
            this._groupings = new List<Grouping>();
            this._lastGrouping = null;
        }
        private IEqualityComparer<TKey> _keyComparer;
        private List<Grouping> _groupings;
        private Grouping _lastGrouping;
 
        private Grouping NextGroup(TKey key)
        {
            if (_lastGrouping == null)
            {
                _lastGrouping = new Grouping(key);
                _groupings.Add(_lastGrouping);
            }
            else if (!_keyComparer.Equals(_lastGrouping.Key, key))
            {
                _lastGrouping = new Grouping(key);
                _groupings.Add(_lastGrouping);
            }
            return _lastGrouping;
        }

        public IEnumerator<IGrouping<TKey, TElement>> GetEnumerator()
        {
            return _groupings.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        class Grouping : IGrouping<TKey, TElement>
        {
            internal Grouping(TKey key)
            {
                this.Key = key;
                this._elements = new List<TElement>();
            }
            public TKey Key { get; private set; }
            private List<TElement> _elements;

            internal void Add(TElement element)
            {
                _elements.Add(element);
            }

            public IEnumerator<TElement> GetEnumerator()
            {
                return _elements.GetEnumerator();
            }

            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }
    }
}

public static partial class EnumerableEx
{
    public static IEnumerable<IGrouping<TKey, TSource>> GroupByConsecutive<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
    {
        return GroupByConsecutive(source, keySelector, null as IEqualityComparer<TKey>);
    }

    public static IEnumerable<IGrouping<TKey, TSource>> GroupByConsecutive<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer)
    {
        return GroupByConsecutive(source, keySelector, Functions.Identity<TSource>, keyComparer);
    }

    public static IEnumerable<IGrouping<TKey, TElement>> GroupByConsecutive<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
    {
        return GroupByConsecutive(source, keySelector, elementSelector, null as IEqualityComparer<TKey>);
    }

    public static IEnumerable<IGrouping<TKey, TElement>> GroupByConsecutive<TSource, TKey, TElement>(
        this IEnumerable<TSource> source,
        Func<TSource, TKey> keySelector,
        Func<TSource, TElement> elementSelector,
        IEqualityComparer<TKey> keyComparer)
    {
        return ConsecutiveGrouper<TKey, TElement>.Create(source, keySelector, elementSelector, keyComparer ?? EqualityComparer<TKey>.Default);
    }

    internal class ConsecutiveGrouper<TKey, TElement> : IEnumerable<IGrouping<TKey, TElement>>
    {
        internal static ConsecutiveGrouper<TKey, TElement> Create<TSource, TKey, TElement>(
            IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            Func<TSource, TElement> elementSelector,
            IEqualityComparer<TKey> keyComparer)
        {
            source.ThrowIfNull("source");
            keySelector.ThrowIfNull("keySelector");
            elementSelector.ThrowIfNull("elementSelector");

            var grouper = new ConsecutiveGrouper<TKey, TElement>(keyComparer);
            foreach (var item in source)
            {
                grouper.NextGroup(keySelector(item)).Add(elementSelector(item));
            }
            return grouper;
        }

        private ConsecutiveGrouper(IEqualityComparer<TKey> keyComparer)
        {
            this._keyComparer = keyComparer ?? EqualityComparer<TKey>.Default;
            this._groupings = new List<Grouping>();
        }
        private IEqualityComparer<TKey> _keyComparer;
        private List<Grouping> _groupings;

        private Grouping NextGroup(TKey key)
        {
            Grouping grouping;

            if (_groupings.Count == 0)
            {
                grouping = new Grouping(key);
                _groupings.Add(grouping);
            }
            else
            {
                grouping = _groupings[_groupings.Count - 1];
                if (!_keyComparer.Equals(grouping.Key, key))
                {
                    grouping = new Grouping(key);
                    _groupings.Add(grouping);
                }
            }
            return grouping;
        }

        public IEnumerator<IGrouping<TKey, TElement>> GetEnumerator()
        {
            return _groupings.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        class Grouping : IGrouping<TKey, TElement>
        {
            internal Grouping(TKey key)
            {
                this.Key = key;
                this._elements = new List<TElement>();
            }
            public TKey Key { get; private set; }
            private List<TElement> _elements;

            internal void Add(TElement element)
            {
                _elements.Add(element);
            }

            public IEnumerator<TElement> GetEnumerator()
            {
                return _elements.GetEnumerator();
            }

            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }
    }
}

public static partial class EnumerableEx
{
    public static IEnumerable<IGrouping<TKey, TSource>> GroupByConsecutive<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
    {
        return GroupByConsecutive(source, keySelector, null as IEqualityComparer<TKey>);
    }

    public static IEnumerable<IGrouping<TKey, TSource>> GroupByConsecutive<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer)
    {
        return GroupByConsecutive(source, keySelector, Functions.Identity<TSource>, keyComparer);
    }

    public static IEnumerable<IGrouping<TKey, TElement>> GroupByConsecutive<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
    {
        return GroupByConsecutive(source, keySelector, elementSelector, null as IEqualityComparer<TKey>);
    }

    public static IEnumerable<IGrouping<TKey, TElement>> GroupByConsecutive<TSource, TKey, TElement>(
        this IEnumerable<TSource> source,
        Func<TSource, TKey> keySelector,
        Func<TSource, TElement> elementSelector,
        IEqualityComparer<TKey> keyComparer)
    {
        return ConsecutiveGrouper<TKey, TElement>.Create(source, keySelector, elementSelector, keyComparer as IEqualityComparer<TKey>);
    }

    internal class ConsecutiveGrouper<TKey, TElement> : IEnumerable<IGrouping<TKey, TElement>>
    {
        internal static ConsecutiveGrouper<TKey, TElement> Create<TSource, TKey, TElement>(
            IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            Func<TSource, TElement> elementSelector,
            IEqualityComparer<TKey> keyComparer)
        {
            source.ThrowIfNull("source");
            keySelector.ThrowIfNull("keySelector");
            elementSelector.ThrowIfNull("elementSelector");

            var grouper = new ConsecutiveGrouper<TKey, TElement>(keyComparer);
            foreach (var item in source)
            {
                grouper.NextGroup(keySelector(item)).Add(elementSelector(item));
            }
            return grouper;
        }

        private ConsecutiveGrouper(IEqualityComparer<TKey> keyComparer)
        {
            this._keyComparer = keyComparer ?? EqualityComparer<TKey>.Default;
            this._groupings = new List<Grouping>();
        }
        private IEqualityComparer<TKey> _keyComparer;
        private List<Grouping> _groupings;

        private Grouping NextGroup(TKey key)
        {
            Grouping grouping;

            if (_groupings.Count == 0)
            {
                grouping = new Grouping(key);
                _groupings.Add(grouping);
            }
            else
            {
                grouping = _groupings[_groupings.Count - 1];
                if (!_keyComparer.Equals(grouping.Key, key))
                {
                    grouping = new Grouping(key);
                    _groupings.Add(grouping);
                }
            }
            return grouping;
        }

        public IEnumerator<IGrouping<TKey, TElement>> GetEnumerator()
        {
            return _groupings.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        class Grouping : IGrouping<TKey, TElement>
        {
            internal Grouping(TKey key)
            {
                this.Key = key;
                this._elements = new List<TElement>();
            }
            public TKey Key { get; private set; }
            private List<TElement> _elements;

            internal void Add(TElement element)
            {
                _elements.Add(element);
            }

            public IEnumerator<TElement> GetEnumerator()
            {
                return _elements.GetEnumerator();
            }

            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }
    }
}

public static partial class EnumerableEx
{
    public static IEnumerable<IGrouping<TKey, TSource>> GroupByConsecutive<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
    {
        return GroupByConsecutive(source, keySelector, null as IEqualityComparer<TKey>);
    }

    public static IEnumerable<IGrouping<TKey, TSource>> GroupByConsecutive<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer)
    {
        return GroupByConsecutive(source, keySelector, Functions.Identity<TSource>, keyComparer);
    }

    public static IEnumerable<IGrouping<TKey, TElement>> GroupByConsecutive<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
    {
        return GroupByConsecutive(source, keySelector, elementSelector, null as IEqualityComparer<TKey>);
    }

    public static IEnumerable<IGrouping<TKey, TElement>> GroupByConsecutive<TSource, TKey, TElement>(
        IEnumerable<TSource> source,
        Func<TSource, TKey> keySelector,
        Func<TSource, TElement> elementSelector,
        IEqualityComparer<TKey> keyComparer)
    {
        return ConsecutiveGrouper<TKey, TElement>.Create(source, keySelector, elementSelector, keyComparer ?? EqualityComparer<TKey>.Default);
    }

    internal class ConsecutiveGrouper<TKey, TElement> : IEnumerable<IGrouping<TKey, TElement>>
    {
        internal static ConsecutiveGrouper<TKey, TElement> Create<TSource, TKey, TElement>(
            IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            Func<TSource, TElement> elementSelector,
            IEqualityComparer<TKey> keyComparer)
        {
            source.ThrowIfNull("source");
            keySelector.ThrowIfNull("keySelector");
            elementSelector.ThrowIfNull("elementSelector");

            var grouper = new ConsecutiveGrouper<TKey, TElement>(keyComparer);
            foreach (var item in source)
            {
                grouper.NextGroup(keySelector(item)).Add(elementSelector(item));
            }
            return grouper;
        }

        private ConsecutiveGrouper(IEqualityComparer<TKey> keyComparer)
        {
            this._keyComparer = keyComparer ?? EqualityComparer<TKey>.Default;
            this._groupings = new List<Grouping>();
        }
        private IEqualityComparer<TKey> _keyComparer;
        private List<Grouping> _groupings;

        private Grouping NextGroup(TKey key)
        {
            Grouping grouping;

            if (_groupings.Count == 0)
            {
                grouping = new Grouping(key);
                _groupings.Add(grouping);
            }
            else
            {
                grouping = _groupings[_groupings.Count - 1];
                if (!_keyComparer.Equals(grouping.Key, key))
                {
                    grouping = new Grouping(key);
                    _groupings.Add(grouping);
                }
            }
            return grouping;
        }

        public IEnumerator<IGrouping<TKey, TElement>> GetEnumerator()
        {
            return _groupings.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        class Grouping : IGrouping<TKey, TElement>
        {
            internal Grouping(TKey key)
            {
                this.Key = key;
                this._elements = new List<TElement>();
            }
            public TKey Key { get; private set; }
            private List<TElement> _elements;

            internal void Add(TElement element)
            {
                _elements.Add(element);
            }

            public IEnumerator<TElement> GetEnumerator()
            {
                return _elements.GetEnumerator();
            }

            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }
    }
}

public static partial class EnumerableEx
{
    public static IEnumerable<IGrouping<TKey, TSource>> GroupByConsecutive<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
    {
        return GroupByConsecutive(source, keySelector, null as IEqualityComparer<TKey>);
    }

    public static IEnumerable<IGrouping<TKey, TSource>> GroupByConsecutive<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer)
    {
        return GroupByConsecutive(source, keySelector, Functions.Identity<TSource>, keyComparer);
    }

    public static IEnumerable<IGrouping<TKey, TElement>> GroupByConsecutive<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
    {
        return GroupByConsecutive(source, keySelector, elementSelector, null as IEqualityComparer<TKey>);
    }

    public static IEnumerable<IGrouping<TKey, TElement>> GroupByConsecutive<TSource, TKey, TElement>(
        this IEnumerable<TSource> source,
        Func<TSource, TKey> keySelector,
        Func<TSource, TElement> elementSelector,
        IEqualityComparer<TKey> keyComparer)
    {
        return ConsecutiveGrouper<TKey, TElement>.Create(source, keySelector, elementSelector, keyComparer ?? EqualityComparer<TKey>.Default);
    }

    internal class ConsecutiveGrouper<TKey, TElement> : IEnumerable<IGrouping<TKey, TElement>>
    {
        internal static ConsecutiveGrouper<TKey, TElement> Create<TSource, TKey, TElement>(
            IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            Func<TSource, TElement> elementSelector,
            IEqualityComparer<TKey> keyComparer)
        {
            source.ThrowIfNull("source");
            keySelector.ThrowIfNull("keySelector");
            elementSelector.ThrowIfNull("elementSelector");

            var grouper = new ConsecutiveGrouper<TKey, TElement>(keyComparer);
            foreach (var item in source)
            {
                grouper.NextGroup(keySelector(item)).Add(elementSelector(item));
            }
            return grouper;
        }

        private ConsecutiveGrouper(IEqualityComparer<TKey> keyComparer)
        {
            this._keyComparer = keyComparer ?? EqualityComparer<TKey>.Default;
            this._groupings = new List<Grouping>();
        }
        private IEqualityComparer<TKey> _keyComparer;
        private List<Grouping> _groupings;

        private Grouping NextGroup(TKey key)
        {
            Grouping grouping;

            if (_groupings.Count == 0)
            {
                grouping = new Grouping(key);
                _groupings.Add(grouping);
            }
            else
            {
                grouping = _groupings[_groupings.Count - 1];
                if (!_keyComparer.Equals(grouping.Key, key))
                {
                    grouping = new Grouping(key);
                    _groupings.Add(grouping);
                }
            }
            return grouping;
        }

        public IEnumerator<IGrouping<TKey, TElement>> GetEnumerator()
        {
            return _groupings.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        class Grouping : IGrouping<TKey, TElement>
        {
            internal Grouping(TKey key)
            {
                this.Key = key;
                this._elements = new List<TElement>();
            }
            public TKey Key { get; private set; }
            private List<TElement> _elements;

            internal void Add(TElement element)
            {
                _elements.Add(element);
            }

            public IEnumerator<TElement> GetEnumerator()
            {
                return _elements.GetEnumerator();
            }

            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }
    }
}