IEnumerable扩展方法

// /***********************************************************
// *  项目名称：   YunDouTax.BaseLib
// *  文件名称：   EnumerableExtension.cs
// *  功能描述：   
// *  代码作者：   云勇
// *  创建时间：   2017年12月25日 11:50  
// *  更新时间：   2018年01月01日 21:12
// ************************************************************/

namespace YunDouTax.BaseLib.Extensions
{
    /// <summary>
    /// 提供一组用于查询实现 System.Collections.Generic.IEnumerable`1 的对象的 static 方法。
    /// </summary>
    public static class EnumerableExtension
    {
        /// <summary>
        /// 通过合并元素的索引将序列的每个元素投影到新表中。
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <typeparam name="TResult">The type of the result.</typeparam>
        /// <param name="source">The source.</param>
        /// <param name="selector">The selector.</param>
        /// <returns></returns>
        /// <exception cref="System.ArgumentNullException">selector cann't be null.</exception>
        public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
        {
            if (selector == null)
            {
                throw new ArgumentNullException("selector cann't be null.");
            }

            foreach (TSource item in source)
            {
                if (item == null)
                {
                    continue;
                }

                TResult result = selector(item);
                if (result == null)
                {
                    continue;
                }

                yield return result;
            }
        }

        /// <summary>
        /// 基于谓词筛选值序列。
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <param name="source">The source.</param>
        /// <param name="predicate">The predicate.</param>
        /// <returns></returns>
        /// <exception cref="System.ArgumentNullException">predicate cann't be null.</exception>
        public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (predicate == null)
            {
                throw new ArgumentNullException("predicate cann't be null.");
            }

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

        /// <summary>
        /// 返回序列中的元素数量。
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <param name="source">The source.</param>
        /// <returns></returns>
        public static int Count<TSource>(this IEnumerable<TSource> source)
        {
            int count = 0;
            foreach (TSource item in source)
            {
                count++;
            }

            return count;
        }

        /// <summary>
        /// 返回一个数字，表示在指定的序列中满足条件的元素数量。
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <param name="source">The source.</param>
        /// <param name="predicate">The predicate.</param>
        /// <returns></returns>
        /// <exception cref="System.ArgumentNullException">predicate cann't be null.</exception>
        public static int Count<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (predicate == null)
            {
                throw new ArgumentNullException("predicate cann't be null.");
            }

            int count = 0;
            foreach (TSource item in source)
            {
                if (predicate(item))
                {
                    count++;
                }
            }

            return count;
        }

        /// <summary>
        /// 返回序列中的第一个元素；如果序列中不包含任何元素，则返回默认值。
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <param name="source">The source.</param>
        /// <param name="predicate">The predicate.</param>
        /// <returns></returns>
        public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate = null)
        {
            if (source == null)
            {
                return default(TSource);
            }

            foreach (TSource item in source)
            {
                if (predicate == null)
                {
                    return item;
                }

                if (predicate != null && predicate(item))
                {
                    return item;
                }
            }

            return default(TSource);
        }

        /// <summary>
        /// 从 System.Collections.Generic.IEnumerable`1 创建一个 System.Collections.Generic.List`1。
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <param name="source">The source.</param>
        /// <returns></returns>
        public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
        {
            return new List<TSource>(source);
        }

        /// <summary>
        /// 从 System.Collections.Generic.IEnumerable`1 创建一个数组。
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <param name="source">The source.</param>
        /// <returns></returns>
        public static TSource[] ToArray<TSource>(this IEnumerable<TSource> source)
        {
            TSource[] array = new TSource[source.Count()];

            int index = 0;
            foreach (TSource item in source)
            {
                array[index++] = item;
            }

            return array;
        }

        /// <summary>
        /// 通过使用默认的相等比较器确定序列是否包含指定的元素。
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <param name="source">The source.</param>
        /// <param name="value">The value.</param>
        /// <returns>
        ///   <c>true</c> if [contains] [the specified value]; otherwise, <c>false</c>.
        /// </returns>
        public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource value)
        {
            foreach (TSource item in source)
            {
                if (item.Equals(value))
                {
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// 判断指定的序列是否为空
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <param name="source">The source.</param>
        /// <returns>
        ///   <c>true</c> if the specified source is empty; otherwise, <c>false</c>.
        /// </returns>
        public static bool IsEmpty<TSource>(this IEnumerable<TSource> source)
        {
            return source == null || source.Count() == 0;
        }

        /// <summary>
        /// 根据键按升序对序列的元素排序
        /// </summary>
        public static IEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) where TKey : IComparable
        {
            List<TSource> ls = source.ToList();
            for (int i = 0; i < ls.Count; i++)
            {
                TKey min = keySelector(ls[i]);
                for (int j = i + 1; j < ls.Count; j++)
                {
                    TKey key = keySelector(ls[j]);
                    if (min.CompareTo(key) > 0)
                    {
                        min = key;

                        TSource tmp = ls[i];
                        ls[i] = ls[j];
                        ls[j] = tmp;
                    }
                }

                yield return ls[i];
            }
        }


        /// <summary>
        /// Alternates the specified first.
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <param name="first">The first.</param>
        /// <param name="second">The second.</param>
        /// <returns></returns>
        public static IEnumerable<TSource> Alternate<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
        {
            using (IEnumerator<TSource> e1 = first.GetEnumerator())
            using (IEnumerator<TSource> e2 = second.GetEnumerator())
            {
                while (e1.MoveNext() && e2.MoveNext())
                {
                    yield return e1.Current;
                    yield return e2.Current;
                }
            }
        }

        /// <summary>
        /// Appends the specified source.
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <param name="source">The source.</param>
        /// <param name="element">The element.</param>
        /// <returns>IEnumerable<TSource></returns>
        public static IEnumerable<TSource> Append<TSource>(this IEnumerable<TSource> source, TSource element)
        {
            using (IEnumerator<TSource> e1 = source.GetEnumerator())
            {
                while (e1.MoveNext())
                {
                    yield return e1.Current;
                }
            }

            yield return element;
        }

        /// <summary>
        /// Determines whether [contains] [the specified source].
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <typeparam name="TResult">The type of the result.</typeparam>
        /// <param name="source">The source.</param>
        /// <param name="value">The value.</param>
        /// <param name="selector">The selector.</param>
        /// <returns>
        ///     <c>true</c> if [contains] [the specified source]; otherwise, <c>false</c>.
        /// </returns>
        public static bool Contains<TSource, TResult>(this IEnumerable<TSource> source, TResult value, Func<TSource, TResult> selector)
        {
            foreach (TSource sourceItem in source)
            {
                TResult sourceValue = selector(sourceItem);
                if (sourceValue.Equals(value))
                {
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// Prepends the specified source.
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <param name="source">The source.</param>
        /// <param name="element">The element.</param>
        /// <returns>IEnumerable<TSource></returns>
        public static IEnumerable<TSource> Prepend<TSource>(this IEnumerable<TSource> source, TSource element)
        {
            yield return element;

            using (IEnumerator<TSource> e1 = source.GetEnumerator())
            {
                while (e1.MoveNext())
                {
                    yield return e1.Current;
                }
            }
        }
    }
}