WPF_常用集合扩展方法

    public static class EnumerableExtensions
    {
        public static void ForEach<T>(this IEnumerable<T> enumerable, Action<T> toAction)
        {
            foreach (T each in enumerable)
            {
                toAction(each);
            }
        }

        public static void ForEach<T>(this IEnumerable<T> enumerable, Action<T, int> toAction)
        {
            int i = 0;
            foreach (T each in enumerable)
            {
                toAction(each, i++);
            }
        }

        public static void ForEach<T>(this T[] enumerable, Action<T> toAction)
        {
            foreach (T each in enumerable)
            {
                toAction(each);
            }
        }

        public static void ForEach<T>(this T[] enumerable, Action<T, int> toAction)
        {
            int i = 0;
            foreach (T each in enumerable)
            {
                toAction(each, i++);
            }
        }


        /// <summary>
        /// 判断<paramref name="enumerable" />集合是否只有一个元素。
        /// </summary>
        public static bool IsSingle<T>(this IEnumerable<T> enumerable)
        {
            return enumerable.Any() && !enumerable.Skip(1).Any();
        }

        /// <summary>
        /// 判断<paramref name="enumerable" />集合是否只有一个符合<paramref name="predicate" />条件的元素。
        /// </summary>
        public static bool IsSingle<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate)
        {
            int count = 0;
            foreach (T each in enumerable)
            {
                if (predicate(each))
                {
                    count++;
                    if (count == 2)
                    {
                        break;
                    }
                }
            }

            return count == 1;
        }

        /// <summary>
        /// 判断集合中的元素是否是同一种类型。
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="source">对象</param>
        /// <returns>只有一种元素<see langword="true"/></returns>
        public static bool IsSingleKind<T>(this IEnumerable<T> source)
        {
            using (var enumerator = source.GetEnumerator())
            {
                if (enumerator.MoveNext() == false)
                {
                    return false;
                }

                T first = enumerator.Current;
                while (enumerator.MoveNext())
                {
                    var current = enumerator.Current;
                    if (first == null)
                    {
                        if (current != null)
                        {
                            return false;
                        }
                    }
                    else if (first.Equals(current) == false)
                    {
                        return false;
                    }
                }
            }

            return true;
        }


        /// <summary>
        /// 返回集合中的最大值，如果没有就返回默认值<paramref name="defaultValue"/>
        /// </summary>
        public static T MaxOrDefault<T>(this IEnumerable<T> enumerable, T defaultValue = default(T))
        {
            return enumerable.Any() ? enumerable.Max() : defaultValue;
        }

        /// <summary>
        /// 返回集合中符合指定条件<paramref name="selector"/>的最大值，如果没有就返回默认值<paramref name="defaultValue"/>
        /// </summary>
        public static TResult MaxOrDefault<TSource, TResult>(this IEnumerable<TSource> enumerable,
                                                             Func<TSource, TResult> selector,
                                                             TResult defaultValue = default(TResult))
        {
            return enumerable.Any() ? enumerable.Max(selector) : defaultValue;
        }

        /// <summary>
        /// 返回集合中的最小值，如果没有就返回默认值<paramref name="defaultValue"/>
        /// </summary>
        public static T MinOrDefault<T>(this IEnumerable<T> enumerable, T defaultValue = default(T))
        {
            return enumerable.Any() ? enumerable.Min() : defaultValue;
        }

        /// <summary>
        /// 返回集合中符合指定条件<paramref name="selector"/>的最小值，如果没有就返回默认值<paramref name="defaultValue"/>
        /// </summary>
        public static TResult MinOrDefault<TSource, TResult>(this IEnumerable<TSource> enumerable,
                                                             Func<TSource, TResult> selector,
                                                             TResult defaultValue = default(TResult))
        {
            return enumerable.Any() ? enumerable.Min(selector) : defaultValue;
        }
    }