mono/mcs/class/System.Core/System.Linq/Enumerable.cs

// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
//
// Authors:
//        Marek Safar ([email protected])
//        Antonello Provenzano  <[email protected]>
//        Alejandro Serrano "Serras" ([email protected])
//

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace System.Linq
{
    public static class Enumerable
    {
        #region Aggregate
        public static TSource Aggregate<TSource>(this IEnumerable<TSource> source, Func<TSource, TSource, TSource> func)
        {
            if (source == null)
                throw new ArgumentNullException ("source");
            if (func == null)
                throw new ArgumentNullException ("func");
            
            // custom foreach so that we can efficiently throw an exception 
            // if zero elements and treat the first element differently
            using (IEnumerator<TSource> enumerator = source.GetEnumerator ()) {
                if (!enumerator.MoveNext ())
                    throw new InvalidOperationException ("No elements in source list");
                
                TSource folded = enumerator.Current;
                while (enumerator.MoveNext ())
                    folded = func (folded, enumerator.Current);
                return folded;
            }
        }


        public static TAccumulate Aggregate<TSource, TAccumulate>(this IEnumerable<TSource> source,
            TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func)
        {
            if (source == null || func == null)
                throw new ArgumentNullException();

            TAccumulate folded = seed;
            foreach (TSource element in source)
                folded = func(folded, element);
            return folded;
        }


        public static TResult Aggregate<TSource, TAccumulate, TResult>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector)
        {
            if (source == null)
                throw new ArgumentNullException("source");
            if (func == null)
                throw new ArgumentNullException("func");
            if (resultSelector == null)
                throw new ArgumentNullException("resultSelector");

            TAccumulate result = seed;
            foreach (TSource e in source)
                result = func(result, e);
            return resultSelector(result);
        }
        #endregion

        #region All
        public static bool All<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null || predicate == null)
                throw new ArgumentNullException();

            foreach (TSource element in source)
                if (!predicate(element))
                    return false;
            return true;
        }
        #endregion

        #region Any
        public static bool Any<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            foreach (TSource element in source)
                return true;
            return false;
        }


        public static bool Any<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null || predicate == null)
                throw new ArgumentNullException();

            foreach (TSource element in source)
                if (predicate(element))
                    return true;
            return false;
        }
        #endregion

        #region AsEnumerable
        public static IEnumerable<TSource> AsEnumerable<TSource>(this IEnumerable<TSource> source)
        {
            return source;
        }
        #endregion

        #region Average
        public static double Average(this IEnumerable<int> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            long sum = 0;
            long counter = 0;
            foreach (int element in source)
            {
                sum += element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return (double)sum / (double)counter;
        }


        public static double? Average(this IEnumerable<int?> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            long sum = 0;
            long counter = 0;
            foreach (int? element in source)
            {
                if (element.HasValue)
                {
                    onlyNull = false;
                    sum += element.Value;
                    counter++;
                }
            }
            return (onlyNull ? null : (double?)sum / (double?)counter);
        }


        public static double Average(this IEnumerable<long> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            long sum = 0;
            long counter = 0;
            foreach (long element in source)
            {
                sum += element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return (double)sum / (double)counter;
        }


        public static double? Average(this IEnumerable<long?> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            long sum = 0;
            long counter = 0;
            foreach (long? element in source)
            {
                if (element.HasValue)
                {
                    onlyNull = false;
                    sum += element.Value;
                    counter++;
                }
            }
            return (onlyNull ? null : (double?)sum / (double?)counter);
        }


        public static double Average(this IEnumerable<double> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            double sum = 0;
            double counter = 0;
            foreach (double element in source)
            {
                sum += element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return sum / counter;
        }


        public static double? Average(this IEnumerable<double?> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            double sum = 0;
            double counter = 0;
            foreach (double? element in source)
            {
                if (element.HasValue)
                {
                    onlyNull = false;
                    sum += element.Value;
                    counter++;
                }
            }
            return (onlyNull ? null : (double?)(sum / counter));
        }


        public static decimal Average(this IEnumerable<decimal> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            decimal sum = 0;
            decimal counter = 0;
            foreach (decimal element in source)
            {
                sum += element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return sum / counter;
        }


        public static decimal? Average(this IEnumerable<decimal?> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            decimal sum = 0;
            decimal counter = 0;
            foreach (decimal? element in source)
            {
                if (element.HasValue)
                {
                    onlyNull = false;
                    sum += element.Value;
                    counter++;
                }
            }
            return (onlyNull ? null : (decimal?)(sum / counter));
        }


        public static double Average<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            long sum = 0;
            long counter = 0;
            foreach (TSource item in source)
            {
                sum += selector(item);
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return (double)sum / (double)counter;
        }


        public static double? Average<TSource>(this IEnumerable<TSource> source, Func<TSource, int?> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            long sum = 0;
            long counter = 0;
            foreach (TSource item in source)
            {
                int? element = selector(item);
                if (element.HasValue)
                {
                    onlyNull = false;
                    sum += element.Value;
                    counter++;
                }
            }
            return (onlyNull ? null : (double?)sum / (double?)counter);
        }


        public static double Average<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            long sum = 0;
            long counter = 0;
            foreach (TSource item in source)
            {
                sum += selector(item);
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return (double)sum / (double)counter;
        }


        public static double? Average<TSource>(this IEnumerable<TSource> source, Func<TSource, long?> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            long sum = 0;
            long counter = 0;
            foreach (TSource item in source)
            {
                long? element = selector(item);
                if (element.HasValue)
                {
                    onlyNull = false;
                    sum += element.Value;
                    counter++;
                }
            }
            return (onlyNull ? null : (double?)sum / (double?)counter);
        }


        public static double Average<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            double sum = 0;
            double counter = 0;
            foreach (TSource item in source)
            {
                sum += selector(item);
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return sum / counter;
        }


        public static double? Average<TSource>(this IEnumerable<TSource> source, Func<TSource, double?> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            double sum = 0;
            double counter = 0;
            foreach (TSource item in source)
            {
                double? element = selector(item);
                if (element.HasValue)
                {
                    onlyNull = false;
                    sum += element.Value;
                    counter++;
                }
            }
            return (onlyNull ? null : (double?)(sum / counter));
        }


        public static decimal Average<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            decimal sum = 0;
            decimal counter = 0;
            foreach (TSource item in source)
            {
                sum += selector(item);
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return sum / counter;
        }


        public static decimal? Average<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            decimal sum = 0;
            decimal counter = 0;
            foreach (TSource item in source)
            {
                decimal? element = selector(item);
                if (element.HasValue)
                {
                    onlyNull = false;
                    sum += element.Value;
                    counter++;
                }
            }
            return (onlyNull ? null : (decimal?)(sum / counter));
        }
        #endregion

        #region Cast
        public static IEnumerable<TResult> Cast<TResult>(this IEnumerable source)
        {
            if (source == null)
                throw new ArgumentNullException();

            foreach (object element in source)
                yield return (TResult)element;
        }
        #endregion

        #region Concat
        public static IEnumerable<TSource> Concat<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
        {
            if (first == null || second == null)
                throw new ArgumentNullException();

            foreach (TSource element in first)
                yield return element;
            foreach (TSource element in second)
                yield return element;
        }

        #endregion

        #region Contains

        public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource value)
        {
            if (source is ICollection<TSource>)
            {
                ICollection<TSource> collection = (ICollection<TSource>)source;
                return collection.Contains(value);
            }

            return Contains<TSource>(source, value, null);
        }


        public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource value, IEqualityComparer<TSource> comparer)
        {
            if (source == null)
                throw new ArgumentNullException("source");

            if (comparer == null)
                comparer = EqualityComparer<TSource>.Default;


            foreach (TSource e in source)
            {
                if (comparer.Equals(e, value))
                    return true;
            }

            return false;
        }
        #endregion

        #region Count
        public static int Count<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            if (source is ICollection<TSource>)
                return ((ICollection<TSource>)source).Count;
            else
            {
                int counter = 0;
                foreach (TSource element in source)
                    counter++;
                return counter;
            }
        }


        public static int Count<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            int counter = 0;
            foreach (TSource element in source)
                if (selector(element))
                    counter++;

            return counter;
        }
        #endregion

        #region DefaultIfEmpty

        public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool noYield = true;
            foreach (TSource item in source)
            {
                noYield = false;
                yield return item;
            }

            if (noYield)
                yield return default(TSource);
        }


        public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable<TSource> source, TSource defaultValue)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool noYield = true;
            foreach (TSource item in source)
            {
                noYield = false;
                yield return item;
            }

            if (noYield)
                yield return defaultValue;
        }

        #endregion

        #region Distinct

        public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source)
        {
            return Distinct<TSource>(source, null);
        }

        public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
        {
            if (source == null)
                throw new ArgumentNullException();

            if (comparer == null)
                comparer = EqualityComparer<TSource>.Default;

            List<TSource> items = new List<TSource>();
            foreach (TSource element in source)
            {
                if (!Contains (items, element, comparer))
                {
                    items.Add(element);
                    yield return element;
                }
            }
        }
        #endregion

        #region ElementAt

        public static TSource ElementAt<TSource>(this IEnumerable<TSource> source, int index)
        {
            if (source == null)
                throw new ArgumentNullException();
            if (index < 0)
                throw new ArgumentOutOfRangeException();

            if (source is IList<TSource>)
                return ((IList<TSource>)source)[index];
            else
            {
                int counter = 0;
                foreach (TSource element in source)
                {
                    if (counter == index)
                        return element;
                    counter++;
                }
                throw new ArgumentOutOfRangeException();
            }
        }

        #endregion

        #region ElementAtOrDefault

        public static TSource ElementAtOrDefault<TSource>(this IEnumerable<TSource> source, int index)
        {
            if (source == null)
                throw new ArgumentNullException();
            if (index < 0)
                return default(TSource);

            if (source is IList<TSource>)
            {
                if (((IList<TSource>)source).Count >= index)
                    return default(TSource);
                else
                    return ((IList<TSource>)source)[index];
            }
            else
            {
                int counter = 0;
                foreach (TSource element in source)
                {
                    if (counter == index)
                        return element;
                    counter++;
                }
                return default(TSource);
            }
        }

        #endregion

        #region Empty
        public static IEnumerable<TResult> Empty<TResult>()
        {
            return new List<TResult>();
        }
        #endregion

        #region Except

        public static IEnumerable<TSource> Except<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
        {
            return Except(first, second, null);
        }

        public static IEnumerable<TSource> Except<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
        {
            if (first == null || second == null)
                throw new ArgumentNullException();

            if (comparer == null)
                comparer = EqualityComparer<TSource>.Default;

            List<TSource> items = new List<TSource>(Distinct(first));
            foreach (TSource element in second)
            {
                int index = IndexOf(items, element, comparer);
                if (index == -1)
                    items.Add(element);
                else
                    items.RemoveAt(index);
            }
            foreach (TSource item in items)
                yield return item;
        }

        #endregion

        #region First

        public static TSource First<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            foreach (TSource element in source)
                return element;

            throw new InvalidOperationException();
        }


        public static TSource First<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null || predicate == null)
                throw new ArgumentNullException();

            foreach (TSource element in source)
            {
                if (predicate(element))
                    return element;
            }

            throw new InvalidOperationException();
        }

        #endregion

        #region FirstOrDefault

        public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            foreach (TSource element in source)
                return element;

            return default(TSource);
        }


        public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null || predicate == null)
                throw new ArgumentNullException();

            foreach (TSource element in source)
            {
                if (predicate(element))
                    return element;
            }

            return default(TSource);
        }

        #endregion

        #region GroupBy

        private static List<T> ContainsGroup<K, T>(
                Dictionary<K, List<T>> items, K key, IEqualityComparer<K> comparer)
        {
            IEqualityComparer<K> comparerInUse = (comparer ?? EqualityComparer<K>.Default);
            foreach (KeyValuePair<K, List<T>> value in items)
            {
                if (comparerInUse.Equals(value.Key, key))
                    return value.Value;
            }
            return null;
        }


        public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source, 
            Func<TSource, TKey> keySelector)
        {
            return GroupBy<TSource, TKey>(source, keySelector, null);
        }


        public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
        {
            if (source == null || keySelector == null)
                throw new ArgumentNullException();

            Dictionary<TKey, List<TSource>> groups = new Dictionary<TKey, List<TSource>>();
            List<TSource> nullList = new List<TSource>();
            int counter = 0;
            int nullCounter = -1;

            foreach (TSource element in source)
            {
                TKey key = keySelector(element);
                if (key == null)
                {
                    nullList.Add(element);
                    if (nullCounter == -1)
                    {
                        nullCounter = counter;
                        counter++;
                    }
                }
                else
                {
                    List<TSource> group = ContainsGroup<TKey, TSource>(groups, key, comparer);
                    if (group == null)
                    {
                        group = new List<TSource>();
                        groups.Add(key, group);
                        counter++;
                    }
                    group.Add(element);
                }
            }

            counter = 0;
            foreach (KeyValuePair<TKey, List<TSource>> group in groups)
            {
                if (counter == nullCounter)
                {
                    Grouping<TKey, TSource> nullGroup = new Grouping<TKey, TSource>(default(TKey), nullList);
                    yield return nullGroup;
                    counter++;
                }
                Grouping<TKey, TSource> grouping = new Grouping<TKey, TSource>(group.Key, group.Value);
                yield return grouping;
                counter++;
            }
        }


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


        public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
        {
            if (source == null || keySelector == null || elementSelector == null)
                throw new ArgumentNullException();

            Dictionary<TKey, List<TElement>> groups = new Dictionary<TKey, List<TElement>>();
            List<TElement> nullList = new List<TElement>();
            int counter = 0;
            int nullCounter = -1;

            foreach (TSource item in source)
            {
                TKey key = keySelector(item);
                TElement element = elementSelector(item);
                if (key == null)
                {
                    nullList.Add(element);
                    if (nullCounter == -1)
                    {
                        nullCounter = counter;
                        counter++;
                    }
                }
                else
                {
                    List<TElement> group = ContainsGroup<TKey, TElement>(groups, key, comparer);
                    if (group == null)
                    {
                        group = new List<TElement>();
                        groups.Add(key, group);
                        counter++;
                    }
                    group.Add(element);
                }
            }

            counter = 0;
            foreach (KeyValuePair<TKey, List<TElement>> group in groups)
            {
                if (counter == nullCounter)
                {
                    Grouping<TKey, TElement> nullGroup = new Grouping<TKey, TElement>(default(TKey), nullList);
                    yield return nullGroup;
                    counter++;
                }
                Grouping<TKey, TElement> grouping = new Grouping<TKey, TElement>(group.Key, group.Value);
                yield return grouping;
                counter++;
            }
        }

        #endregion

        # region GroupJoin

        public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer,
            IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, 
            Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector)
        {
            return GroupJoin(outer, inner, outerKeySelector, innerKeySelector, resultSelector, null);
        }

        public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer,
            IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector,
            Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector, 
            IEqualityComparer<TKey> comparer)
        {
            if (outer == null || inner == null || outerKeySelector == null ||
                innerKeySelector == null || resultSelector == null)
                throw new ArgumentNullException();

            if (comparer == null)
                comparer = EqualityComparer<TKey>.Default;

            Lookup<TKey, TInner> innerKeys = ToLookup<TInner, TKey>(inner, innerKeySelector, comparer);
            /*Dictionary<K, List<U>> innerKeys = new Dictionary<K, List<U>> ();
            foreach (U element in inner)
            {
                    K innerKey = innerKeySelector (element);
                    if (!innerKeys.ContainsKey (innerKey))
                            innerKeys.Add (innerKey, new List<U> ());
                    innerKeys[innerKey].Add (element);
            }*/

            foreach (TOuter element in outer)
            {
                TKey outerKey = outerKeySelector(element);
                if (innerKeys.Contains(outerKey))
                    yield return resultSelector(element, innerKeys[outerKey]);
            }
        }

        #endregion

        #region Intersect


        public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
        {
            if (first == null || second == null)
                throw new ArgumentNullException();

            List<TSource> items = new List<TSource>(Distinct(first));
            bool[] marked = new bool[items.Count];
            for (int i = 0; i < marked.Length; i++)
                marked[i] = false;

            foreach (TSource element in second)
            {
                int index = IndexOf(items, element);
                if (index != -1)
                    marked[index] = true;
            }
            for (int i = 0; i < marked.Length; i++)
            {
                if (marked[i])
                    yield return items[i];
            }
        }

        #endregion

        # region Join

        public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer,
            IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector,
            Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer)
        {
            if (outer == null || inner == null || outerKeySelector == null ||
                    innerKeySelector == null || resultSelector == null)
                throw new ArgumentNullException();

            if (comparer == null)
                comparer = EqualityComparer<TKey>.Default;

            Lookup<TKey, TInner> innerKeys = ToLookup<TInner, TKey>(inner, innerKeySelector, comparer);
            /*Dictionary<K, List<U>> innerKeys = new Dictionary<K, List<U>> ();
            foreach (U element in inner)
            {
                    K innerKey = innerKeySelector (element);
                    if (!innerKeys.ContainsKey (innerKey))
                            innerKeys.Add (innerKey, new List<U> ());
                    innerKeys[innerKey].Add (element);
            }*/

            foreach (TOuter element in outer)
            {
                TKey outerKey = outerKeySelector(element);
                if (innerKeys.Contains(outerKey))
                {
                    foreach (TInner innerElement in innerKeys[outerKey])
                        yield return resultSelector(element, innerElement);
                }
            }
        }

        public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer,
            IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector,
            Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector)
        {
            return Join<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, null);
        }
        # endregion

        #region Last

        public static TSource Last<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool noElements = true;
            TSource lastElement = default(TSource);
            foreach (TSource element in source)
            {
                if (noElements) noElements = false;
                lastElement = element;
            }

            if (!noElements)
                return lastElement;
            else
                throw new InvalidOperationException();
        }

        public static TSource Last<TSource>(this IEnumerable<TSource> source,
                Func<TSource, bool> predicate)
        {
            if (source == null || predicate == null)
                throw new ArgumentNullException();

            bool noElements = true;
            TSource lastElement = default(TSource);
            foreach (TSource element in source)
            {
                if (predicate(element))
                {
                    if (noElements) noElements = false;
                    lastElement = element;
                }
            }

            if (!noElements)
                return lastElement;
            else
                throw new InvalidOperationException();
        }

        #endregion

        #region LastOrDefault

        public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            TSource lastElement = default(TSource);
            foreach (TSource element in source)
                lastElement = element;

            return lastElement;
        }

        public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source,
            Func<TSource, bool> predicate)
        {
            if (source == null || predicate == null)
                throw new ArgumentNullException();

            TSource lastElement = default(TSource);
            foreach (TSource element in source)
            {
                if (predicate(element))
                    lastElement = element;
            }

            return lastElement;
        }

        #endregion

        #region LongCount
        public static long LongCount<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            long counter = 0;
            foreach (TSource element in source)
                counter++;
            return counter;
        }


        public static long LongCount<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            long counter = 0;
            foreach (TSource element in source)
                if (selector(element))
                    counter++;

            return counter;
        }

        #endregion

        #region Max

        public static int Max(this IEnumerable<int> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            int maximum = int.MinValue;
            int counter = 0;
            foreach (int element in source)
            {
                if (element > maximum)
                    maximum = element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return maximum;
        }


        public static int? Max(this IEnumerable<int?> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            int? maximum = int.MinValue;
            foreach (int? element in source)
            {
                if (element.HasValue)
                {
                    onlyNull = false;
                    if (element > maximum)
                        maximum = element;
                }
            }
            return (onlyNull ? null : maximum);
        }


        public static long Max(this IEnumerable<long> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            long maximum = long.MinValue;
            int counter = 0;
            foreach (long element in source)
            {
                if (element > maximum)
                    maximum = element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return maximum;
        }


        public static long? Max(this IEnumerable<long?> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            long? maximum = long.MinValue;
            foreach (long? element in source)
            {
                if (element.HasValue)
                {
                    onlyNull = false;
                    if (element > maximum)
                        maximum = element;
                }
            }
            return (onlyNull ? null : maximum);
        }


        public static double Max(this IEnumerable<double> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            double maximum = double.MinValue;
            int counter = 0;
            foreach (double element in source)
            {
                if (element > maximum)
                    maximum = element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return maximum;
        }


        public static double? Max(this IEnumerable<double?> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            double? maximum = double.MinValue;
            foreach (double? element in source)
            {
                if (element.HasValue)
                {
                    onlyNull = false;
                    if (element > maximum)
                        maximum = element;
                }
            }
            return (onlyNull ? null : maximum);
        }


        public static decimal Max(this IEnumerable<decimal> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            decimal maximum = decimal.MinValue;
            int counter = 0;
            foreach (decimal element in source)
            {
                if (element > maximum)
                    maximum = element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return maximum;
        }


        public static decimal? Max(this IEnumerable<decimal?> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            decimal? maximum = decimal.MinValue;
            foreach (decimal? element in source)
            {
                if (element.HasValue)
                {
                    onlyNull = false;
                    if (element > maximum)
                        maximum = element;
                }
            }
            return (onlyNull ? null : maximum);
        }


        public static TSource Max<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool notAssigned = true;
            TSource maximum = default(TSource);
            int counter = 0;
            foreach (TSource element in source)
            {
                if (notAssigned)
                {
                    maximum = element;
                    notAssigned = false;
                }
                else
                {
                    int comparison;
                    if (element is IComparable<TSource>)
                        comparison = ((IComparable<TSource>)element).CompareTo(maximum);
                    else if (element is System.IComparable)
                        comparison = ((System.IComparable)element).CompareTo(maximum);
                    else
                        throw new ArgumentNullException();

                    if (comparison > 0)
                        maximum = element;
                }
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return maximum;
        }


        public static int Max<TSource>(this IEnumerable<TSource> source,
                Func<TSource, int> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            int maximum = int.MinValue;
            int counter = 0;
            foreach (TSource item in source)
            {
                int element = selector(item);
                if (element > maximum)
                    maximum = element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return maximum;
        }


        public static int? Max<TSource>(this IEnumerable<TSource> source,
                Func<TSource, int?> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            int? maximum = int.MinValue;
            foreach (TSource item in source)
            {
                int? element = selector(item);
                if (element.HasValue)
                {
                    onlyNull = false;
                    if (element > maximum)
                        maximum = element;
                }
            }
            return (onlyNull ? null : maximum);
        }


        public static long Max<TSource>(this IEnumerable<TSource> source,
            Func<TSource, long> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            long maximum = long.MinValue;
            int counter = 0;
            foreach (TSource item in source)
            {
                long element = selector(item);
                if (element > maximum)
                    maximum = element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return maximum;
        }


        public static long? Max<TSource>(this IEnumerable<TSource> source,
            Func<TSource, long?> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            long? maximum = long.MinValue;
            foreach (TSource item in source)
            {
                long? element = selector(item);
                if (element.HasValue)
                {
                    onlyNull = false;
                    if (element > maximum)
                        maximum = element;
                }
            }
            return (onlyNull ? null : maximum);
        }


        public static double Max<TSource>(this IEnumerable<TSource> source,
            Func<TSource, double> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            double maximum = double.MinValue;
            int counter = 0;
            foreach (TSource item in source)
            {
                double element = selector(item);
                if (element > maximum)
                    maximum = element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return maximum;
        }


        public static double? Max<TSource>(this IEnumerable<TSource> source,
            Func<TSource, double?> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            double? maximum = double.MinValue;
            foreach (TSource item in source)
            {
                double? element = selector(item);
                if (element.HasValue)
                {
                    onlyNull = false;
                    if (element > maximum)
                        maximum = element;
                }
            }
            return (onlyNull ? null : maximum);
        }


        public static decimal Max<TSource>(this IEnumerable<TSource> source,
            Func<TSource, decimal> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            decimal maximum = decimal.MinValue;
            int counter = 0;
            foreach (TSource item in source)
            {
                decimal element = selector(item);
                if (element > maximum)
                    maximum = element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return maximum;
        }


        public static decimal? Max<TSource>(this IEnumerable<TSource> source,
            Func<TSource, decimal?> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            decimal? maximum = decimal.MinValue;
            foreach (TSource item in source)
            {
                decimal? element = selector(item);
                if (element.HasValue)
                {
                    onlyNull = false;
                    if (element > maximum)
                        maximum = element;
                }
            }
            return (onlyNull ? null : maximum);
        }


        public static TResult Max<TSource, TResult>(this IEnumerable<TSource> source,
                Func<TSource, TResult> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            bool notAssigned = true;
            TResult maximum = default(TResult);
            int counter = 0;
            foreach (TSource item in source)
            {
                TResult element = selector(item);
                if (notAssigned)
                {
                    maximum = element;
                    notAssigned = false;
                }
                else
                {
                    int comparison;
                    if (element is IComparable<TResult>)
                        comparison = ((IComparable<TResult>)element).CompareTo(maximum);
                    else if (element is System.IComparable)
                        comparison = ((System.IComparable)element).CompareTo(maximum);
                    else
                        throw new ArgumentNullException();

                    if (comparison > 0)
                        maximum = element;
                }
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return maximum;
        }

        #endregion

        #region Min

        public static int Min(this IEnumerable<int> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            int minimum = int.MaxValue;
            int counter = 0;
            foreach (int element in source)
            {
                if (element < minimum)
                    minimum = element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return minimum;
        }


        public static int? Min(this IEnumerable<int?> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            int? minimum = int.MaxValue;
            foreach (int? element in source)
            {
                if (element.HasValue)
                {
                    onlyNull = false;
                    if (element < minimum)
                        minimum = element;
                }
            }
            return (onlyNull ? null : minimum);
        }

        public static long Min(this IEnumerable<long> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            long minimum = long.MaxValue;
            int counter = 0;
            foreach (long element in source)
            {
                if (element < minimum)
                    minimum = element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return minimum;
        }


        public static long? Min(this IEnumerable<long?> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            long? minimum = long.MaxValue;
            foreach (long? element in source)
            {
                if (element.HasValue)
                {
                    onlyNull = false;
                    if (element < minimum)
                        minimum = element;
                }
            }
            return (onlyNull ? null : minimum);
        }


        public static double Min(this IEnumerable<double> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            double minimum = double.MaxValue;
            int counter = 0;
            foreach (double element in source)
            {
                if (element < minimum)
                    minimum = element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return minimum;
        }


        public static double? Min(this IEnumerable<double?> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            double? minimum = double.MaxValue;
            foreach (double? element in source)
            {
                if (element.HasValue)
                {
                    onlyNull = false;
                    if (element < minimum)
                        minimum = element;
                }
            }
            return (onlyNull ? null : minimum);
        }


        public static decimal Min(this IEnumerable<decimal> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            decimal minimum = decimal.MaxValue;
            int counter = 0;
            foreach (decimal element in source)
            {
                if (element < minimum)
                    minimum = element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return minimum;
        }


        public static decimal? Min(this IEnumerable<decimal?> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            decimal? minimum = decimal.MaxValue;
            foreach (decimal? element in source)
            {
                if (element.HasValue)
                {
                    onlyNull = false;
                    if (element < minimum)
                        minimum = element;
                }
            }
            return (onlyNull ? null : minimum);
        }


        public static TSource Min<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool notAssigned = true;
            TSource minimum = default(TSource);
            int counter = 0;
            foreach (TSource element in source)
            {
                if (notAssigned)
                {
                    minimum = element;
                    notAssigned = false;
                }
                else
                {
                    int comparison;
                    if (element is IComparable<TSource>)
                        comparison = ((IComparable<TSource>)element).CompareTo(minimum);
                    else if (element is System.IComparable)
                        comparison = ((System.IComparable)element).CompareTo(minimum);
                    else
                        throw new ArgumentNullException();

                    if (comparison < 0)
                        minimum = element;
                }
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return minimum;
        }


        public static int Min<TSource>(this IEnumerable<TSource> source,
            Func<TSource, int> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            int minimum = int.MaxValue;
            int counter = 0;
            foreach (TSource item in source)
            {
                int element = selector(item);
                if (element < minimum)
                    minimum = element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return minimum;
        }


        public static int? Min<TSource>(this IEnumerable<TSource> source,
                Func<TSource, int?> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            int? minimum = int.MaxValue;
            foreach (TSource item in source)
            {
                int? element = selector(item);
                if (element.HasValue)
                {
                    onlyNull = false;
                    if (element < minimum)
                        minimum = element;
                }
            }
            return (onlyNull ? null : minimum);
        }


        public static long Min<TSource>(this IEnumerable<TSource> source,
                Func<TSource, long> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            long minimum = long.MaxValue;
            int counter = 0;
            foreach (TSource item in source)
            {
                long element = selector(item);
                if (element < minimum)
                    minimum = element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return minimum;
        }


        public static long? Min<TSource>(this IEnumerable<TSource> source,
                Func<TSource, long?> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            long? minimum = long.MaxValue;
            foreach (TSource item in source)
            {
                long? element = selector(item);
                if (element.HasValue)
                {
                    onlyNull = false;
                    if (element < minimum)
                        minimum = element;
                }
            }
            return (onlyNull ? null : minimum);
        }


        public static double Min<TSource>(this IEnumerable<TSource> source,
            Func<TSource, double> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            double minimum = double.MaxValue;
            int counter = 0;
            foreach (TSource item in source)
            {
                double element = selector(item);
                if (element < minimum)
                    minimum = element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return minimum;
        }


        public static double? Min<TSource>(this IEnumerable<TSource> source,
                Func<TSource, double?> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            double? minimum = double.MaxValue;
            foreach (TSource item in source)
            {
                double? element = selector(item);
                if (element.HasValue)
                {
                    onlyNull = false;
                    if (element < minimum)
                        minimum = element;
                }
            }
            return (onlyNull ? null : minimum);
        }


        public static decimal Min<TSource>(this IEnumerable<TSource> source,
                Func<TSource, decimal> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            decimal minimum = decimal.MaxValue;
            int counter = 0;
            foreach (TSource item in source)
            {
                decimal element = selector(item);
                if (element < minimum)
                    minimum = element;
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return minimum;
        }


        public static decimal? Min<TSource>(this IEnumerable<TSource> source,
                Func<TSource, decimal?> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            bool onlyNull = true;
            decimal? minimum = decimal.MaxValue;
            foreach (TSource item in source)
            {
                decimal? element = selector(item);
                if (element.HasValue)
                {
                    onlyNull = false;
                    if (element < minimum)
                        minimum = element;
                }
            }
            return (onlyNull ? null : minimum);
        }


        public static TResult Min<TSource, TResult>(this IEnumerable<TSource> source,
                Func<TSource, TResult> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            bool notAssigned = true;
            TResult minimum = default(TResult);
            int counter = 0;
            foreach (TSource item in source)
            {
                TResult element = selector(item);
                if (notAssigned)
                {
                    minimum = element;
                    notAssigned = false;
                }
                else
                {
                    int comparison;
                    if (element is IComparable<TResult>)
                        comparison = ((IComparable<TResult>)element).CompareTo(minimum);
                    else if (element is System.IComparable)
                        comparison = ((System.IComparable)element).CompareTo(minimum);
                    else
                        throw new ArgumentNullException();

                    if (comparison < 0)
                        minimum = element;
                }
                counter++;
            }

            if (counter == 0)
                throw new InvalidOperationException();
            else
                return minimum;
        }

        #endregion

        #region OfType

        public static IEnumerable<TResult> OfType<TResult>(this IEnumerable source)
        {
            if (source == null)
                throw new ArgumentNullException();

            foreach (object element in source)
                if (element is TResult)
                    yield return (TResult)element;
        }

        #endregion

        #region OrderBy

        public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source,
                Func<TSource, TKey> keySelector)
        {
            return OrderBy<TSource, TKey>(source, keySelector, null);
        }


        public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source,
                Func<TSource, TKey> keySelector,
                IComparer<TKey> comparer)
        {
            if (source == null || keySelector == null)
                throw new ArgumentNullException();

            return new InternalOrderedSequence<TSource, TKey>(
                    source, keySelector, comparer, false);
        }

        #endregion

        #region OrderByDescending

        public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source,
                Func<TSource, TKey> keySelector)
        {
            return OrderByDescending<TSource, TKey>(source, keySelector, null);
        }


        public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source,
                Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
        {
            if (source == null || keySelector == null)
                throw new ArgumentNullException();

            return new InternalOrderedSequence<TSource, TKey>(
                    source, keySelector, comparer, true);
        }

        #endregion

        #region Range

        public static IEnumerable<int> Range(int start, int count)
        {
            if (count < 0 || (start + count - 1) > int.MaxValue)
                throw new ArgumentOutOfRangeException();

            for (int i = start; i < (start + count - 1); i++)
                yield return i;
        }

        #endregion

        #region Repeat

        public static IEnumerable<TResult> Repeat<TResult>(TResult element, int count)
        {
            if (count < 0)
                throw new ArgumentOutOfRangeException();

            for (int i = 0; i < count; i++)
                yield return element;
        }

        #endregion


        #region Reverse

        public static IEnumerable<TSource> Reverse<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            List<TSource> list = new List<TSource>(source);
            list.Reverse();
            return list;
        }

        #endregion

        #region Select

        public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source,
                Func<TSource, TResult> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            foreach (TSource element in source)
                yield return selector(element);
        }


        public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source,
                Func<TSource, int, TResult> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            int counter = 0;
            foreach (TSource element in source)
            {
                yield return selector(element, counter);
                counter++;
            }
        }

        #endregion

        #region SelectMany

        public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source,
                Func<TSource, IEnumerable<TResult>> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            foreach (TSource element in source)
                foreach (TResult item in selector(element))
                    yield return item;
        }


        public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source,
                Func<TSource, int, IEnumerable<TResult>> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            int counter = 0;
            foreach (TSource element in source) {
                foreach (TResult item in selector(element, counter++))
                    yield return item;
                counter++;
            }
        }
        
	public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult> (this IEnumerable<TSource> source,
		Func<TSource, IEnumerable <TCollection>> collectionSelector, Func <TSource, TCollection, TResult> selector)        
	{
		if (source == null || collectionSelector == null || selector == null)
			throw new ArgumentNullException ();
		
		foreach (TSource element in source)
			foreach (TCollection collection in collectionSelector (element))
				yield return selector (element, collection);
	}

        public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult> (this IEnumerable<TSource> source,
		Func<TSource, int, IEnumerable <TCollection>> collectionSelector, Func <TSource, TCollection, TResult> selector)        
	{
		if (source == null || collectionSelector == null || selector == null)
			throw new ArgumentNullException ();
		
		int counter = 0;		
		foreach (TSource element in source)
			foreach (TCollection collection in collectionSelector (element, counter++))
				yield return selector (element, collection);	
	}

        #endregion

        #region Single

        public static TSource Single<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool otherElement = false;
            TSource singleElement = default(TSource);
            foreach (TSource element in source)
            {
                if (otherElement) throw new InvalidOperationException();
                if (!otherElement) otherElement = true;
                singleElement = element;
            }

            if (otherElement)
                return singleElement;
            else
                throw new InvalidOperationException();
        }


        public static TSource Single<TSource>(this IEnumerable<TSource> source,
                Func<TSource, bool> predicate)
        {
            if (source == null || predicate == null)
                throw new ArgumentNullException();

            bool otherElement = false;
            TSource singleElement = default(TSource);
            foreach (TSource element in source)
            {
                if (predicate(element))
                {
                    if (otherElement) throw new InvalidOperationException();
                    if (!otherElement) otherElement = true;
                    singleElement = element;
                }
            }

            if (otherElement)
                return singleElement;
            else
                throw new InvalidOperationException();
        }

        #endregion

        #region SingleOrDefault

        public static TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            bool otherElement = false;
            TSource singleElement = default(TSource);
            foreach (TSource element in source)
            {
                if (otherElement) throw new InvalidOperationException();
                if (!otherElement) otherElement = true;
                singleElement = element;
            }

            return singleElement;
        }


        public static TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source,
                Func<TSource, bool> predicate)
        {
            if (source == null || predicate == null)
                throw new ArgumentNullException();

            bool otherElement = false;
            TSource singleElement = default(TSource);
            foreach (TSource element in source)
            {
                if (predicate(element))
                {
                    if (otherElement) throw new InvalidOperationException();
                    if (!otherElement) otherElement = true;
                    singleElement = element;
                }
            }

            return singleElement;
        }

        #endregion

        #region Skip
        public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> source, int count)
        {
            if (source == null)
                throw new NotSupportedException();

            int i = 0;
            foreach (TSource e in source)
            {
                if (++i < count)
                    continue;
                yield return e;
            }
        }
        #endregion

        #region SkipWhile


        public static IEnumerable<TSource> SkipWhile<TSource>(
                this IEnumerable<TSource> source,
                Func<TSource, bool> predicate)
        {
            if (source == null || predicate == null)
                throw new ArgumentNullException();

            bool yield = false;

            foreach (TSource element in source)
            {
                if (yield)
                    yield return element;
                else
                    if (!predicate(element))
                    {
                        yield return element;
                        yield = true;
                    }
            }
        }


        public static IEnumerable<TSource> SkipWhile<TSource>(this IEnumerable<TSource> source,
                Func<TSource, int, bool> predicate)
        {
            if (source == null || predicate == null)
                throw new ArgumentNullException();

            int counter = 0;
            bool yield = false;

            foreach (TSource element in source)
            {
                if (yield)
                    yield return element;
                else
                    if (!predicate(element, counter))
                    {
                        yield return element;
                        yield = true;
                    }
                counter++;
            }
        }

        #endregion

        #region Sum

        public static int Sum(this IEnumerable<int> source)
        {
            if (source == null)
                throw new ArgumentNullException("source");

            int sum = 0;
            foreach (int element in source)
                sum += element;

            return sum;
        }


        public static int Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            int sum = 0;
            foreach (TSource element in source)
                sum += selector(element);

            return sum;
        }


        public static int? Sum(this IEnumerable<int?> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            int? sum = 0;
            foreach (int? element in source)
                if (element.HasValue)
                    sum += element.Value;

            return sum;
        }


        public static int? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, int?> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            int? sum = 0;
            foreach (TSource element in source)
            {
                int? item = selector(element);
                if (item.HasValue)
                    sum += item.Value;
            }

            return sum;
        }


        public static long Sum(this IEnumerable<long> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            long sum = 0;
            foreach (long element in source)
                sum += element;

            return sum;
        }


        public static long Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            long sum = 0;
            foreach (TSource element in source)
                sum += selector(element);

            return sum;
        }


        public static long? Sum(this IEnumerable<long?> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            long? sum = 0;
            foreach (long? element in source)
                if (element.HasValue)
                    sum += element.Value;

            return sum;
        }


        public static long? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, long?> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            long? sum = 0;
            foreach (TSource element in source)
            {
                long? item = selector(element);
                if (item.HasValue)
                    sum += item.Value;
            }

            return sum;
        }


        public static double Sum(this IEnumerable<double> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            double sum = 0;
            foreach (double element in source)
                sum += element;

            return sum;
        }


        public static double Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            double sum = 0;
            foreach (TSource element in source)
                sum += selector(element);

            return sum;
        }


        public static double? Sum(this IEnumerable<double?> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            double? sum = 0;
            foreach (double? element in source)
                if (element.HasValue)
                    sum += element.Value;

            return sum;
        }


        public static double? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, double?> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            double? sum = 0;
            foreach (TSource element in source)
            {
                double? item = selector(element);
                if (item.HasValue)
                    sum += item.Value;
            }

            return sum;
        }


        public static decimal Sum(this IEnumerable<decimal> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            decimal sum = 0;
            foreach (decimal element in source)
                sum += element;

            return sum;
        }


        public static decimal Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            decimal sum = 0;
            foreach (TSource element in source)
                sum += selector(element);

            return sum;
        }


        public static decimal? Sum(this IEnumerable<decimal?> source)
        {
            if (source == null)
                throw new ArgumentNullException();

            decimal? sum = 0;
            foreach (decimal? element in source)
                if (element.HasValue)
                    sum += element.Value;

            return sum;
        }


        public static decimal? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
        {
            if (source == null || selector == null)
                throw new ArgumentNullException();

            decimal? sum = 0;
            foreach (TSource element in source)
            {
                decimal? item = selector(element);
                if (item.HasValue)
                    sum += item.Value;
            }

            return sum;
        }

        #endregion
        #region Take

        public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, int count)
        {
            if (source == null)
                throw new ArgumentNullException();

            if (count <= 0)
                yield break;
            else
            {
                int counter = 0;
                foreach (TSource element in source)
                {
                    yield return element;
                    counter++;
                    if (counter == count)
                        yield break;
                }
            }
        }

        #endregion

        #region TakeWhile

        public static IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null || predicate == null)
                throw new ArgumentNullException();

            foreach (TSource element in source)
            {
                if (predicate(element))
                    yield return element;
                else
                    yield break;
            }
        }

        public static IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
        {
            if (source == null || predicate == null)
                throw new ArgumentNullException();

            int counter = 0;
            foreach (TSource element in source)
            {
                if (predicate(element, counter))
                    yield return element;
                else
                    yield break;
                counter++;
            }
        }

        #endregion

        #region ThenBy

        public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector)
        {
            return ThenBy<TSource, TKey>(source, keySelector, null);
        }


        public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedEnumerable<TSource> source, 
            Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
        {
		if (source == null || keySelector == null)
			throw new ArgumentNullException();

		return source.CreateOrderedEnumerable (keySelector, comparer, false);
        }

        #endregion

        #region ThenByDescending

        public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedEnumerable<TSource> source,
            Func<TSource, TKey> keySelector)
        {
            return ThenByDescending<TSource, TKey>(source, keySelector, null);
        }


        public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedEnumerable<TSource> source,
            Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
        {
		if (source == null || keySelector == null)
			throw new ArgumentNullException();

		return source.CreateOrderedEnumerable (keySelector, comparer, true);
        }

        #endregion

        #region ToArray
        public static TSource[] ToArray<TSource> (this IEnumerable<TSource> source)
        {
            if (source == null)
                throw new ArgumentNullException ();
                        
            List<TSource> list = new List<TSource> (source);
            return list.ToArray ();
        }
                
        #endregion

        #region ToDictionary
        public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
        {
            return ToDictionary<TSource, TKey, TElement>(source, keySelector, elementSelector, null);
        }


        public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
        {
            if (source == null)
                throw new ArgumentNullException("source");
            if (keySelector == null)
                throw new ArgumentNullException("keySelector");
            if (elementSelector == null)
                throw new ArgumentNullException("elementSelector");

            Dictionary<TKey, TElement> dict = new Dictionary<TKey, TElement>(comparer);
            foreach (TSource e in source)
            {
                dict.Add(keySelector(e), elementSelector(e));
            }

            return dict;
        }
        #endregion

        #region ToList
        public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
                throw new ArgumentNullException("source");

            return new List<TSource>(source);
        }
        #endregion

        #region ToLookup

        public static Lookup<TKey, TSource> ToLookup<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
        {
            return ToLookup<TSource, TKey>(source, keySelector, null);
        }


        public static Lookup<TKey, TSource> ToLookup<TSource, TKey>(this IEnumerable<TSource> source, 
            Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
        {
            if (source == null || keySelector == null)
                throw new ArgumentNullException();

            Dictionary<TKey, List<TSource>> dictionary = new Dictionary<TKey, List<TSource>>(comparer ?? EqualityComparer<TKey>.Default);
            foreach (TSource element in source)
            {
                TKey key = keySelector(element);
                if (key == null)
                    throw new ArgumentNullException();
                if (!dictionary.ContainsKey(key))
                    dictionary.Add(key, new List<TSource>());
                dictionary[key].Add(element);
            }
            return new Lookup<TKey, TSource>(dictionary);
        }


        public static Lookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(this IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
        {
            return ToLookup<TSource, TKey, TElement>(source, keySelector, elementSelector, null);
        }


        public static Lookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(this IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
        {
            if (source == null || keySelector == null || elementSelector == null)
                throw new ArgumentNullException();

            Dictionary<TKey, List<TElement>> dictionary = new Dictionary<TKey, List<TElement>>(comparer ?? EqualityComparer<TKey>.Default);
            foreach (TSource element in source)
            {
                TKey key = keySelector(element);
                if (key == null)
                    throw new ArgumentNullException();
                if (!dictionary.ContainsKey(key))
                    dictionary.Add(key, new List<TElement>());
                dictionary[key].Add(elementSelector(element));
            }
            return new Lookup<TKey, TElement>(dictionary);
        }

        #endregion

        #region ToSequence

        public static IEnumerable<T> ToSequence<T>(this IEnumerable<T> source)
        {
            return (IEnumerable<T>)source;
        }

        #endregion

        #region Union


        public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
        {
            if (first == null || second == null)
                throw new ArgumentNullException();

            List<TSource> items = new List<TSource>();
            foreach (TSource element in first)
            {
                if (IndexOf(items, element) == -1)
                {
                    items.Add(element);
                    yield return element;
                }
            }
            foreach (TSource element in second)
            {
                if (IndexOf(items, element) == -1)
                {
                    items.Add(element);
                    yield return element;
                }
            }
        }

        #endregion

        #region Where

        public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source,
                Func<TSource, bool> predicate)
        {
            if (source == null || predicate == null)
                throw new ArgumentNullException();

            foreach (TSource element in source)
                if (predicate(element))
                    yield return element;
        }


        public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source,
                Func<TSource, int, bool> predicate)
        {
            if (source == null || predicate == null)
                throw new ArgumentNullException();

            int counter = 0;
            foreach (TSource element in source)
            {
                if (predicate(element, counter))
                    yield return element;
                counter++;
            }
        }

        #endregion

        // These methods are not included in the
        // .NET Standard Query Operators Specification,
        // but they provide additional useful commands

        #region Compare

        private static bool Equals<T>(T first, T second)
        {
            // Mostly, values in Enumerable<T> 
            // sequences need to be compared using
            // Equals and GetHashCode

            if (first == null || second == null)
                return (first == null && second == null);
            else
                return ((first.Equals(second) ||
                         first.GetHashCode() == second.GetHashCode()));
        }

        #endregion

        #region IndexOf

        static int IndexOf<T>(this IEnumerable<T> source, T item, IEqualityComparer<T> comparer)
        {
            if (comparer == null)
                comparer = EqualityComparer<T>.Default;

            int counter = 0;
            foreach (T element in source)
            {
                if (comparer.Equals(element, item))
                    return counter;
                counter++;
            }
            // The item was not found
            return -1;
        }

        static int IndexOf<T>(this IEnumerable<T> source, T item)
        {
            return IndexOf<T>(source, item, null);
        }
        #endregion

        #region ToReadOnlyCollection
        internal static ReadOnlyCollection<TSource> ToReadOnlyCollection<TSource>(IEnumerable<TSource> source)
        {
            if (source == null)
                return new ReadOnlyCollection<TSource>(new List<TSource>());

            if (typeof(ReadOnlyCollection<TSource>).IsInstanceOfType(source))
                return source as ReadOnlyCollection<TSource>;

            return new ReadOnlyCollection<TSource>(ToArray<TSource>(source));
        }
        #endregion
    }
}