C# - 配列ヘルパー クラス

C# - 配列ヘルパー クラス

C# の Linq には配列を展開するメソッドがほとんどありませんでしたが、検索、並べ替え、最大値などの一般的なメソッドが拡張されました。

using System;
using System.Collections.Generic;

public static class ArrayHelper
{
    
    
    /// <summary>
    /// 拓展方法执行前检测数组是否合规
    /// </summary>
    /// <returns>True : 可继续操作</returns>
    /// <exception cref="ArgumentNullException"></exception>
    static bool Operatable<T>(this T[] array)
    {
    
    
        if (array == null)
            throw new ArgumentNullException("array");

        return array.Length > 0;
    }

    public static int IndexOf<T>(this T[] array, T item, int startIndex = 0) => array.IndexOf(item, startIndex, array.Length - startIndex - 1);

    public static int IndexOf<T>(this T[] array, T item, int startIndex, int count)
    {
    
    
        if (!array.Operatable())
            return -1;

        if (startIndex >= array.Length || startIndex < 0)
            throw new ArgumentOutOfRangeException("startIndex");

        if (startIndex + count >= array.Length)
            throw new ArgumentOutOfRangeException("count");

        for (int i = startIndex; i < startIndex + count; i++)
        {
    
    
            var current = array[i];
            if (item.Equals(current))
                return i;
        }

        return -1;
    }

    /// <summary>
    /// 查找满足条件(相等）的单个元素(有多个时返回第一个）
    /// </summary>
    /// <typeparam name="T">元素类型</typeparam>
    /// <param name="array">数组</param>
    /// <param name="condition">比较方法（委托）</param>
    /// <returns>返回目标对象</returns>
    public static T Find<T>(this T[] array, Predicate<T> match)
    {
    
    
        if (!array.Operatable())
            return default;

        for (int i = 0; i < array.Length; i++)
        {
    
    
            T item = array[i];
            if (match(item))
                return item;
        }

        return default;
    }

    /// <summary>
    /// 查找满足条件(相等）的多个元素
    /// </summary>
    /// <typeparam name="T">元素类型</typeparam>
    /// <param name="array">数组</param>
    /// <param name="condition">比较方法（委托）</param>
    /// <returns>返回目标对象</returns>
    public static List<T> FindAll<T>(this T[] array, Predicate<T> match)
    {
    
    
        if (!array.Operatable())
            return default;

        List<T> list = new List<T>(array.Length);
        for (int i = 0; i < array.Length; i++)
        {
    
    
            if (match(array[i]))
                list.Add(array[i]);
        }
        return list;
    }

    /// <summary>
    /// 查找数组中满足条件的最大值
    /// </summary>
    /// <typeparam name="T">数组类型</typeparam>
    /// <typeparam name="Q">比较依据的数据类型</typeparam>
    /// <param name="array">数组</param>
    /// <param name="condition">比较依据方法</param>
    /// <returns></returns>
    public static T Max<T, Q>(this T[] array, Func<T, Q> condition) where Q : IComparable
    {
    
    
        if (!array.Operatable())
            return default;

        T maxT = array[0];
        for (int i = 1; i < array.Length; i++)
        {
    
    
            if (condition(array[i]).CompareTo(condition(maxT)) > 0)
                maxT = array[i];
        }

        return maxT;
    }

    /// <summary>
    /// 查找数组中满足条件的最小值
    /// </summary>
    /// <typeparam name="T">数组类型</typeparam>
    /// <typeparam name="Q">比较依据的数据类型</typeparam>
    /// <param name="array">数组</param>
    /// <param name="condition">比较依据方法</param>
    /// <returns></returns>
    public static T Min<T, Q>(this T[] array, Func<T, Q> condition) where Q : IComparable
    {
    
    
        if (!array.Operatable())
            return default;

        T minT = array[0];
        for (int i = 1; i < array.Length; i++)
        {
    
    
            if (condition(array[i]).CompareTo(condition(minT)) < 0)
                minT = array[i];
        }

        return minT;
    }

    /// <summary>
    /// 数组升序排序
    /// </summary>
    /// <typeparam name="T">元素类型</typeparam>
    /// <typeparam name="Q">比较依据</typeparam>
    /// <param name="array">待排序数组</param>
    /// <param name="condition">排序依据方法</param>
    public static void Sort_ascending<T, Q>(this T[] array, Func<T, Q> condition) where Q : IComparable
    {
    
    
        if (!array.Operatable())
            return;

        //冒泡排序
        for (int i = 0; i < array.Length - 1; i++)
            for (int j = i + 1; j < array.Length; j++)
                if (condition(array[j]).CompareTo(condition(array[i])) > 0)
                {
    
    
                    T temp = array[i];
                    array[j] = array[j];
                    array[i] = temp;
                }
    }

    /// <summary>
    /// 数组降序排序
    /// </summary>
    /// <typeparam name="T">元素类型</typeparam>
    /// <typeparam name="Q">比较依据</typeparam>
    /// <param name="array">待排序数组</param>
    /// <param name="condition">排序依据方法</param>
    public static void Sort_descending<T, Q>(this T[] array, Func<T, Q> condition) where Q : IComparable
    {
    
    
        if (!array.Operatable())
            return;

        //冒泡排序
        for (int i = 0; i < array.Length - 1; i++)
            for (int j = i + 1; j < array.Length; j++)
                if (condition(array[j]).CompareTo(condition(array[i])) < 0)
                {
    
    
                    T temp = array[i];
                    array[j] = array[j];
                    array[i] = temp;
                }
    }

    /// <summary>
    /// 在每个T中选出Q 返回Q[]  ---例如在所有敌人物体中获得所有敌人的动画脚本
    /// </summary>
    /// <typeparam name="T">元素类型</typeparam>
    /// <typeparam name="Q">需要获取的类型</typeparam>
    /// <param name="array">原数组</param>
    /// <param name="condition">返回需要获取的类型</param>
    /// <returns>获取到类型的数组</returns>
    public static List<Q> Select<T, Q>(this T[] array, Func<T, Q> condition)
    {
    
    
        if (!array.Operatable())
            return default;

        List<Q> result = new List<Q>(array.Length);
        for (int i = 0; i < array.Length; i++)
        {
    
    
            result.Add(result[i]);
        }

        return result;
    }
}