System.Array.cs

ylbtech-System.Array.cs

 

1.返回顶部

1、

#region 程序集 mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
// C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\mscorlib.dll
#endregion

using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Security;

namespace System
{
    //
    // 摘要:
    //     提供一些方法，用于创建、处理、搜索数组并对数组进行排序，从而充当公共语言运行时中所有数组的基类。
    [ComVisible(true)]
    public abstract class Array : ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable
    {
        //
        // 摘要:
        //     获取一个值，该值指示是否同步对 System.Array 的访问（线程安全）。
        //
        // 返回结果:
        //     此属性对于所有数组总是 false。
        public bool IsSynchronized { get; }
        //
        // 摘要:
        //     获取一个值，该值指示 System.Array 是否为只读。
        //
        // 返回结果:
        //     此属性对于所有数组总是 false。
        public bool IsReadOnly { get; }
        //
        // 摘要:
        //     获取可用于同步 System.Array 访问的对象。
        //
        // 返回结果:
        //     可用于同步对 System.Array 的访问的对象。
        public object SyncRoot { get; }
        //
        // 摘要:
        //     获取 System.Array 的秩（维数）。
        //
        // 返回结果:
        //     该 System.Array 的秩（维数）。
        public int Rank { get; }
        //
        // 摘要:
        //     获得一个 64 位整数，该整数表示 System.Array 的所有维数中元素的总数。
        //
        // 返回结果:
        //     一个 64 位整数，表示 System.Array 的所有维数中元素的总数。
        [ComVisible(false)]
        public long LongLength { get; }
        //
        // 摘要:
        //     获得一个 32 位整数，该整数表示 System.Array 的所有维数中元素的总数。
        //
        // 返回结果:
        //     一个 32 位整数，该整数表示 System.Array 的所有维数中的元素总数；如果数组中没有元素，则该值为零。
        //
        // 异常:
        //   T:System.OverflowException:
        //     数组是多维的，并且包括多于 System.Int32.MaxValue 个元素。
        public int Length { get; }
        //
        // 摘要:
        //     获取一个值，该值指示 System.Array 是否具有固定大小。
        //
        // 返回结果:
        //     此属性对于所有数组总是 true。
        public bool IsFixedSize { get; }

        //
        // 摘要:
        //     返回指定数组的只读包装。
        //
        // 参数:
        //   array:
        //     要包装在只读 System.Collections.ObjectModel.ReadOnlyCollection`1 包装中从零开始的一维数组。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     指定数组的只读 System.Collections.ObjectModel.ReadOnlyCollection`1 包装。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        public static ReadOnlyCollection AsReadOnly(T[] array);
        //
        // 摘要:
        //     使用由 System.Array 中每个元素和指定的对象实现的 System.IComparable 接口，在整个一维排序 System.Array 中搜索特定元素。
        //
        // 参数:
        //   array:
        //     要搜索的已排序一维 System.Array。
        //
        //   value:
        //     要搜索的对象。
        //
        // 返回结果:
        //     如果找到 value，则为指定 array 中的指定 value 的索引。 如果找不到 value 且 value 小于 array 中的一个或多个元素，则为一个负数，该负数是大于
        //     value 的第一个元素的索引的按位求补。 如果找不到 value 且 value 大于 array 中的任何元素，则为一个负数，该负数是（最后一个元素的索引加
        //     1）的按位求补。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.RankException:
        //     array 是多维的。
        //
        //   T:System.ArgumentException:
        //     value 是不与 array 的元素兼容的类型。
        //
        //   T:System.InvalidOperationException:
        //     value 没有实现 System.IComparable 接口，并且搜索时遇到没有实现 System.IComparable 接口的元素。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int BinarySearch(Array array, object value);
        //
        // 摘要:
        //     使用指定的 System.Collections.IComparer 接口，在整个一维排序 System.Array 中搜索值。
        //
        // 参数:
        //   array:
        //     要搜索的已排序一维 System.Array。
        //
        //   value:
        //     要搜索的对象。
        //
        //   comparer:
        //     比较元素时要使用的 System.Collections.IComparer 实现。 - 或 - 若为 null，则使用每个元素的 System.IComparable
        //     实现。
        //
        // 返回结果:
        //     如果找到 value，则为指定 array 中的指定 value 的索引。 如果找不到 value 且 value 小于 array 中的一个或多个元素，则为一个负数，该负数是大于
        //     value 的第一个元素的索引的按位求补。 如果找不到 value 且 value 大于 array 中的任何元素，则为一个负数，该负数是（最后一个元素的索引加
        //     1）的按位求补。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.RankException:
        //     array 是多维的。
        //
        //   T:System.ArgumentException:
        //     comparer 是 null，而 value 是不与 array 的元素兼容的类型。
        //
        //   T:System.InvalidOperationException:
        //     comparer 为 null，value 没有实现 System.IComparable 接口，并且搜索时遇到没有实现 System.IComparable
        //     接口的元素。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int BinarySearch(Array array, object value, IComparer comparer);
        //
        // 摘要:
        //     使用指定的 System.Collections.IComparer 接口，在一维排序 System.Array 的某个元素范围中搜索值。
        //
        // 参数:
        //   array:
        //     要搜索的已排序一维 System.Array。
        //
        //   index:
        //     要搜索的范围的起始索引。
        //
        //   length:
        //     要搜索的范围的长度。
        //
        //   value:
        //     要搜索的对象。
        //
        //   comparer:
        //     比较元素时要使用的 System.Collections.IComparer 实现。 - 或 - 若为 null，则使用每个元素的 System.IComparable
        //     实现。
        //
        // 返回结果:
        //     如果找到 value，则为指定 array 中的指定 value 的索引。 如果找不到 value 且 value 小于 array 中的一个或多个元素，则为一个负数，该负数是大于
        //     value 的第一个元素的索引的按位求补。 如果找不到 value 且 value 大于 array 中的任何元素，则为一个负数，该负数是（最后一个元素的索引加
        //     1）的按位求补。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.RankException:
        //     array 是多维的。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 小于 array 的下限。 - 或 - length 小于零。
        //
        //   T:System.ArgumentException:
        //     index 和 length 不指定 array 中的有效范围。 - 或 - comparer 是 null，而 value 是不与 array 的元素兼容的类型。
        //
        //   T:System.InvalidOperationException:
        //     comparer 为 null，value 没有实现 System.IComparable 接口，并且搜索时遇到没有实现 System.IComparable
        //     接口的元素。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        [SecuritySafeCritical]
        public static int BinarySearch(Array array, int index, int length, object value, IComparer comparer);
        //
        // 摘要:
        //     使用由 System.Array 中每个元素和指定的对象实现的 System.IComparable`1 泛型接口，在整个一维排序 System.Array
        //     中搜索特定元素。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维排序 System.Array。
        //
        //   value:
        //     要搜索的对象。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果找到 value，则为指定 array 中的指定 value 的索引。 如果找不到 value 且 value 小于 array 中的一个或多个元素，则为一个负数，该负数是大于
        //     value 的第一个元素的索引的按位求补。 如果找不到 value 且 value 大于 array 中的任何元素，则为一个负数，该负数是（最后一个元素的索引加
        //     1）的按位求补。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.InvalidOperationException:
        //     value 没有实现 System.IComparable`1 泛型接口，并且搜索时遇到没有实现 System.IComparable`1 泛型接口的元素。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int BinarySearch(T[] array, T value);
        //
        // 摘要:
        //     使用指定的 System.Collections.Generic.IComparer`1 泛型接口，在整个一维排序 System.Array 中搜索值。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维排序 System.Array。
        //
        //   value:
        //     要搜索的对象。
        //
        //   comparer:
        //     比较元素时要使用的 System.Collections.Generic.IComparer`1 实现。 - 或 - 若为 null，则使用每个元素的 System.IComparable`1
        //     实现。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果找到 value，则为指定 array 中的指定 value 的索引。 如果找不到 value 且 value 小于 array 中的一个或多个元素，则为一个负数，该负数是大于
        //     value 的第一个元素的索引的按位求补。 如果找不到 value 且 value 大于 array 中的任何元素，则为一个负数，该负数是（最后一个元素的索引加
        //     1）的按位求补。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.ArgumentException:
        //     comparer 是 null，而 value 是不与 array 的元素兼容的类型。
        //
        //   T:System.InvalidOperationException:
        //     comparer 为 null，value 没有实现 System.IComparable`1 泛型接口，并且搜索时遇到没有实现 System.IComparable`1
        //     泛型接口的元素。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int BinarySearch(T[] array, T value, IComparer comparer);
        //
        // 摘要:
        //     使用由 System.Array 中每个元素和指定值实现的 System.IComparable`1 泛型接口，在一维排序 System.Array 的某个元素范围中搜索值。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维排序 System.Array。
        //
        //   index:
        //     要搜索的范围的起始索引。
        //
        //   length:
        //     要搜索的范围的长度。
        //
        //   value:
        //     要搜索的对象。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果找到 value，则为指定 array 中的指定 value 的索引。 如果找不到 value 且 value 小于 array 中的一个或多个元素，则为一个负数，该负数是大于
        //     value 的第一个元素的索引的按位求补。 如果找不到 value 且 value 大于 array 中的任何元素，则为一个负数，该负数是（最后一个元素的索引加
        //     1）的按位求补。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 小于 array 的下限。 - 或 - length 小于零。
        //
        //   T:System.ArgumentException:
        //     index 和 length 不指定 array 中的有效范围。 - 或 - value 是不与 array 的元素兼容的类型。
        //
        //   T:System.InvalidOperationException:
        //     value 没有实现 System.IComparable`1 泛型接口，并且搜索时遇到没有实现 System.IComparable`1 泛型接口的元素。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int BinarySearch(T[] array, int index, int length, T value);
        //
        // 摘要:
        //     使用指定的 System.Collections.Generic.IComparer`1 泛型接口，在一维排序 System.Array 的某个元素范围中搜索值。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维排序 System.Array。
        //
        //   index:
        //     要搜索的范围的起始索引。
        //
        //   length:
        //     要搜索的范围的长度。
        //
        //   value:
        //     要搜索的对象。
        //
        //   comparer:
        //     比较元素时要使用的 System.Collections.Generic.IComparer`1 实现。 - 或 - 若为 null，则使用每个元素的 System.IComparable`1
        //     实现。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果找到 value，则为指定 array 中的指定 value 的索引。 如果找不到 value 且 value 小于 array 中的一个或多个元素，则为一个负数，该负数是大于
        //     value 的第一个元素的索引的按位求补。 如果找不到 value 且 value 大于 array 中的任何元素，则为一个负数，该负数是（最后一个元素的索引加
        //     1）的按位求补。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 小于 array 的下限。 - 或 - length 小于零。
        //
        //   T:System.ArgumentException:
        //     index 和 length 不指定 array 中的有效范围。 - 或 - comparer 是 null，而 value 是不与 array 的元素兼容的类型。
        //
        //   T:System.InvalidOperationException:
        //     comparer 为 null，value 没有实现 System.IComparable`1 泛型接口，并且搜索时遇到没有实现 System.IComparable`1
        //     泛型接口的元素。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int BinarySearch(T[] array, int index, int length, T value, IComparer comparer);
        //
        // 摘要:
        //     使用由 System.Array 中每个元素和指定值实现的 System.IComparable 接口，在一维排序 System.Array 的某个范围中搜索值。
        //
        // 参数:
        //   array:
        //     要搜索的已排序一维 System.Array。
        //
        //   index:
        //     要搜索的范围的起始索引。
        //
        //   length:
        //     要搜索的范围的长度。
        //
        //   value:
        //     要搜索的对象。
        //
        // 返回结果:
        //     如果找到 value，则为指定 array 中的指定 value 的索引。 如果找不到 value 且 value 小于 array 中的一个或多个元素，则为一个负数，该负数是大于
        //     value 的第一个元素的索引的按位求补。 如果找不到 value 且 value 大于 array 中的任何元素，则为一个负数，该负数是（最后一个元素的索引加
        //     1）的按位求补。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.RankException:
        //     array 是多维的。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 小于 array 的下限。 - 或 - length 小于零。
        //
        //   T:System.ArgumentException:
        //     index 和 length 不指定 array 中的有效范围。 - 或 - value 是不与 array 的元素兼容的类型。
        //
        //   T:System.InvalidOperationException:
        //     value 没有实现 System.IComparable 接口，并且搜索时遇到没有实现 System.IComparable 接口的元素。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int BinarySearch(Array array, int index, int length, object value);
        //
        // 摘要:
        //     将 System.Array 中的一系列元素设置为零、false 或 null，具体取决于元素类型。
        //
        // 参数:
        //   array:
        //     System.Array，需要清除其元素。
        //
        //   index:
        //     要清除的一系列元素的起始索引。
        //
        //   length:
        //     要清除的元素数。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.IndexOutOfRangeException:
        //     index 小于 array 的下限。 - 或 - length 小于零。 - 或 - index 与 length 之和大于 System.Array
        //     的大小。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [SecuritySafeCritical]
        public static void Clear(Array array, int index, int length);
        //
        // 摘要:
        //     从指定的源索引开始，复制 System.Array 中的一系列元素，将它们粘贴到另一 System.Array 中（从指定的目标索引开始）。 保证在复制未成功完成的情况下撤消所有更改。
        //
        // 参数:
        //   sourceArray:
        //     System.Array，它包含要复制的数据。
        //
        //   sourceIndex:
        //     一个 32 位整数，它表示 sourceArray 中复制开始处的索引。
        //
        //   destinationArray:
        //     System.Array，它接收数据。
        //
        //   destinationIndex:
        //     一个 32 位整数，它表示 destinationArray 中存储开始处的索引。
        //
        //   length:
        //     一个 32 位整数，它表示要复制的元素数目。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     sourceArray 为 null。 - 或 - destinationArray 为 null。
        //
        //   T:System.RankException:
        //     sourceArray 和 destinationArray 的秩不同。
        //
        //   T:System.ArrayTypeMismatchException:
        //     sourceArray 类型不同于并且不是从 destinationArray 类型派生的。
        //
        //   T:System.InvalidCastException:
        //     sourceArray 中的至少一个元素无法强制转换为 destinationArray 类型。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     sourceIndex 小于 sourceArray 的第一维的下限。 - 或 - destinationIndex 小于 destinationArray
        //     的第一维的下限。 - 或 - length 小于零。
        //
        //   T:System.ArgumentException:
        //     length 大于从 sourceIndex 到 sourceArray 末尾的元素数。 - 或 - length 大于从 destinationIndex
        //     到 destinationArray 末尾的元素数。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [SecuritySafeCritical]
        public static void ConstrainedCopy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length);
        //
        // 摘要:
        //     将一种类型的数组转换为另一种类型的数组。
        //
        // 参数:
        //   array:
        //     要转换为目标类型的从零开始的一维 System.Array。
        //
        //   converter:
        //     一个 System.Converter`2，用于将每个元素从一种类型转换为另一种类型。
        //
        // 类型参数:
        //   TInput:
        //     源数组元素的类型。
        //
        //   TOutput:
        //     目标数组元素的类型。
        //
        // 返回结果:
        //     目标类型的数组，包含从源数组转换而来的元素。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。 - 或 - converter 为 null。
        public static TOutput[] ConvertAll(TInput[] array, Converter converter);
        //
        // 摘要:
        //     从第一个元素开始复制 System.Array 中的一系列元素，将它们粘贴到另一 System.Array 中（从第一个元素开始）。 长度指定为 32 位整数。
        //
        // 参数:
        //   sourceArray:
        //     System.Array，它包含要复制的数据。
        //
        //   destinationArray:
        //     System.Array，它接收数据。
        //
        //   length:
        //     一个 32 位整数，它表示要复制的元素数目。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     sourceArray 为 null。 - 或 - destinationArray 为 null。
        //
        //   T:System.RankException:
        //     sourceArray 和 destinationArray 的秩不同。
        //
        //   T:System.ArrayTypeMismatchException:
        //     sourceArray 和 destinationArray 是不兼容的类型。
        //
        //   T:System.InvalidCastException:
        //     sourceArray 中的至少一个元素无法强制转换为 destinationArray 类型。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     length 小于零。
        //
        //   T:System.ArgumentException:
        //     length 大于 sourceArray 中的元素数。 - 或 - length 大于 destinationArray 中的元素数。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        [SecuritySafeCritical]
        public static void Copy(Array sourceArray, Array destinationArray, int length);
        //
        // 摘要:
        //     从指定的源索引开始，复制 System.Array 中的一系列元素，将它们粘贴到另一 System.Array 中（从指定的目标索引开始）。 长度和索引指定为
        //     64 位整数。
        //
        // 参数:
        //   sourceArray:
        //     System.Array，它包含要复制的数据。
        //
        //   sourceIndex:
        //     一个 64 位整数，它表示 sourceArray 中复制开始处的索引。
        //
        //   destinationArray:
        //     System.Array，它接收数据。
        //
        //   destinationIndex:
        //     一个 64 位整数，它表示 destinationArray 中存储开始处的索引。
        //
        //   length:
        //     一个 64 位整数，它表示要复制的元素数目。 该整数必须介于零和 System.Int32.MaxValue 之间（包括零和 System.Int32.MaxValue）。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     sourceArray 为 null。 - 或 - destinationArray 为 null。
        //
        //   T:System.RankException:
        //     sourceArray 和 destinationArray 的秩不同。
        //
        //   T:System.ArrayTypeMismatchException:
        //     sourceArray 和 destinationArray 是不兼容的类型。
        //
        //   T:System.InvalidCastException:
        //     sourceArray 中的至少一个元素无法强制转换为 destinationArray 类型。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     sourceIndex 不在 sourceArray 的有效索引范围内。 - 或 - destinationIndex 不在 destinationArray
        //     的有效索引范围内。 - 或 - length 小于 0 或大于 System.Int32.MaxValue。
        //
        //   T:System.ArgumentException:
        //     length 大于从 sourceIndex 到 sourceArray 末尾的元素数。 - 或 - length 大于从 destinationIndex
        //     到 destinationArray 末尾的元素数。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        public static void Copy(Array sourceArray, long sourceIndex, Array destinationArray, long destinationIndex, long length);
        //
        // 摘要:
        //     从第一个元素开始复制 System.Array 中的一系列元素，将它们粘贴到另一 System.Array 中（从第一个元素开始）。 长度指定为 64 位整数。
        //
        // 参数:
        //   sourceArray:
        //     System.Array，它包含要复制的数据。
        //
        //   destinationArray:
        //     System.Array，它接收数据。
        //
        //   length:
        //     一个 64 位整数，它表示要复制的元素数目。 该整数必须介于零和 System.Int32.MaxValue 之间（包括零和 System.Int32.MaxValue）。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     sourceArray 为 null。 - 或 - destinationArray 为 null。
        //
        //   T:System.RankException:
        //     sourceArray 和 destinationArray 的秩不同。
        //
        //   T:System.ArrayTypeMismatchException:
        //     sourceArray 和 destinationArray 是不兼容的类型。
        //
        //   T:System.InvalidCastException:
        //     sourceArray 中的至少一个元素无法强制转换为 destinationArray 类型。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     length 小于 0 或大于 System.Int32.MaxValue。
        //
        //   T:System.ArgumentException:
        //     length 大于 sourceArray 中的元素数。 - 或 - length 大于 destinationArray 中的元素数。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        public static void Copy(Array sourceArray, Array destinationArray, long length);
        //
        // 摘要:
        //     从指定的源索引开始，复制 System.Array 中的一系列元素，将它们粘贴到另一 System.Array 中（从指定的目标索引开始）。 长度和索引指定为
        //     32 位整数。
        //
        // 参数:
        //   sourceArray:
        //     System.Array，它包含要复制的数据。
        //
        //   sourceIndex:
        //     一个 32 位整数，它表示 sourceArray 中复制开始处的索引。
        //
        //   destinationArray:
        //     System.Array，它接收数据。
        //
        //   destinationIndex:
        //     一个 32 位整数，它表示 destinationArray 中存储开始处的索引。
        //
        //   length:
        //     一个 32 位整数，它表示要复制的元素数目。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     sourceArray 为 null。 - 或 - destinationArray 为 null。
        //
        //   T:System.RankException:
        //     sourceArray 和 destinationArray 的秩不同。
        //
        //   T:System.ArrayTypeMismatchException:
        //     sourceArray 和 destinationArray 是不兼容的类型。
        //
        //   T:System.InvalidCastException:
        //     sourceArray 中的至少一个元素无法强制转换为 destinationArray 类型。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     sourceIndex 小于 sourceArray 的第一维的下限。 - 或 - destinationIndex 小于 destinationArray
        //     的第一维的下限。 - 或 - length 小于零。
        //
        //   T:System.ArgumentException:
        //     length 大于从 sourceIndex 到 sourceArray 末尾的元素数。 - 或 - length 大于从 destinationIndex
        //     到 destinationArray 末尾的元素数。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        [SecuritySafeCritical]
        public static void Copy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length);
        //
        // 摘要:
        //     创建使用从零开始的索引、具有指定 System.Type 和维长的多维 System.Array。 维的长度在一个 32 位整数数组中指定。
        //
        // 参数:
        //   elementType:
        //     要创建的 System.Array 的 System.Type。
        //
        //   lengths:
        //     一个 32 位整数数组，它表示要创建的 System.Array 中每个维的大小。
        //
        // 返回结果:
        //     使用从零开始的索引、具有指定 System.Type 的新的多维 System.Array，其每个维度都为指定的长度。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     elementType 为 null。 - 或 - lengths 为 null。
        //
        //   T:System.ArgumentException:
        //     elementType 不是有效的 System.Type。 - 或 - lengths 数组包含的元素少于一个。
        //
        //   T:System.NotSupportedException:
        //     不支持 elementType。 例如，不支持 System.Void。 - 或 - elementType 是一个开放式泛型类型。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     lengths 中的任何值都小于零。
        [SecuritySafeCritical]
        public static Array CreateInstance(Type elementType, params int[] lengths);
        //
        // 摘要:
        //     创建使用从零开始的索引、具有指定 System.Type 和维长的三维 System.Array。
        //
        // 参数:
        //   elementType:
        //     要创建的 System.Array 的 System.Type。
        //
        //   length1:
        //     要创建的 System.Array 的第一维的大小。
        //
        //   length2:
        //     要创建的 System.Array 的第二维的大小。
        //
        //   length3:
        //     要创建的 System.Array 的第三维的大小。
        //
        // 返回结果:
        //     使用从零开始的索引、具有指定 System.Type 的新的三维 System.Array，每个维度都为指定的长度。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     elementType 为 null。
        //
        //   T:System.ArgumentException:
        //     elementType 不是有效的 System.Type。
        //
        //   T:System.NotSupportedException:
        //     不支持 elementType。 例如，不支持 System.Void。 - 或 - elementType 是一个开放式泛型类型。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     length1 小于零。 - 或 - length2 小于零。 - 或 - length3 小于零。
        [SecuritySafeCritical]
        public static Array CreateInstance(Type elementType, int length1, int length2, int length3);
        //
        // 摘要:
        //     创建使用从零开始的索引、具有指定 System.Type 和维长的二维 System.Array。
        //
        // 参数:
        //   elementType:
        //     要创建的 System.Array 的 System.Type。
        //
        //   length1:
        //     要创建的 System.Array 的第一维的大小。
        //
        //   length2:
        //     要创建的 System.Array 的第二维的大小。
        //
        // 返回结果:
        //     使用从零开始的索引、具有指定 System.Type 的新的二维 System.Array，其每个维度都为指定的长度。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     elementType 为 null。
        //
        //   T:System.ArgumentException:
        //     elementType 不是有效的 System.Type。
        //
        //   T:System.NotSupportedException:
        //     不支持 elementType。 例如，不支持 System.Void。 - 或 - elementType 是一个开放式泛型类型。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     length1 小于零。 - 或 - length2 小于零。
        [SecuritySafeCritical]
        public static Array CreateInstance(Type elementType, int length1, int length2);
        //
        // 摘要:
        //     创建使用从零开始的索引、具有指定 System.Type 和长度的一维 System.Array。
        //
        // 参数:
        //   elementType:
        //     要创建的 System.Array 的 System.Type。
        //
        //   length:
        //     要创建的 System.Array 的大小。
        //
        // 返回结果:
        //     使用从零开始的索引、具有指定 System.Type 和指定长度的新的一维 System.Array。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     elementType 为 null。
        //
        //   T:System.ArgumentException:
        //     elementType 不是有效的 System.Type。
        //
        //   T:System.NotSupportedException:
        //     不支持 elementType。 例如，不支持 System.Void。 - 或 - elementType 是一个开放式泛型类型。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     length 小于零。
        [SecuritySafeCritical]
        public static Array CreateInstance(Type elementType, int length);
        //
        // 摘要:
        //     创建具有指定下限、指定 System.Type 和维长的多维 System.Array。
        //
        // 参数:
        //   elementType:
        //     要创建的 System.Array 的 System.Type。
        //
        //   lengths:
        //     一维数组，它包含要创建的 System.Array 的每个维度的大小。
        //
        //   lowerBounds:
        //     一维数组，它包含要创建的 System.Array 的每个维度的下限（起始索引）。
        //
        // 返回结果:
        //     新的指定 System.Type 的多维 System.Array，每个维度都有指定的长度和下限。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     elementType 为 null。 - 或 - lengths 为 null。 - 或 - lowerBounds 为 null。
        //
        //   T:System.ArgumentException:
        //     elementType 不是有效的 System.Type。 - 或 - lengths 数组包含的元素少于一个。 - 或 - lengths 和 lowerBounds
        //     数组包含的元素数不同。
        //
        //   T:System.NotSupportedException:
        //     不支持 elementType。 例如，不支持 System.Void。 - 或 - elementType 是一个开放式泛型类型。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     lengths 中的任何值都小于零。 - 或 - lowerBounds 中的任意一个值都很大，因此，维的下限和长度的和大于 System.Int32.MaxValue。
        [SecuritySafeCritical]
        public static Array CreateInstance(Type elementType, int[] lengths, int[] lowerBounds);
        //
        // 摘要:
        //     创建使用从零开始的索引、具有指定 System.Type 和维长的多维 System.Array。 维的长度在一个 64 位整数数组中指定。
        //
        // 参数:
        //   elementType:
        //     要创建的 System.Array 的 System.Type。
        //
        //   lengths:
        //     一个 64 位整数数组，它表示要创建的 System.Array 中每个维的大小。 数组中的每个整数都必须介于零和 System.Int32.MaxValue
        //     之间（包括零和 System.Int32.MaxValue）。
        //
        // 返回结果:
        //     使用从零开始的索引、具有指定 System.Type 的新的多维 System.Array，其每个维度都为指定的长度。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     elementType 为 null。 - 或 - lengths 为 null。
        //
        //   T:System.ArgumentException:
        //     elementType 不是有效的 System.Type。 - 或 - lengths 数组包含的元素少于一个。
        //
        //   T:System.NotSupportedException:
        //     不支持 elementType。 例如，不支持 System.Void。 - 或 - elementType 是一个开放式泛型类型。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     lengths 中的所有值都小于零或大于 System.Int32.MaxValue。
        public static Array CreateInstance(Type elementType, params long[] lengths);
        //
        // 摘要:
        //     确定指定数组包含的元素是否与指定谓词定义的条件匹配。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维 System.Array。
        //
        //   match:
        //     System.Predicate`1，定义要搜索的元素的条件。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果 array 包含一个或多个元素与指定谓词定义的条件匹配，则为 true；否则为 false。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。 - 或 - match 为 null。
        public static bool Exists(T[] array, Predicate match);
        //
        // 摘要:
        //     搜索与指定谓词所定义的条件相匹配的元素，并返回整个 System.Array 中的第一个匹配元素。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维 System.Array。
        //
        //   match:
        //     System.Predicate`1，定义要搜索的元素的条件。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果找到与指定谓词定义的条件匹配的第一个元素，则为该元素；否则为类型 T 的默认值。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。 - 或 - match 为 null。
        public static T Find(T[] array, Predicate match);
        //
        // 摘要:
        //     检索与指定谓词定义的条件匹配的所有元素。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维 System.Array。
        //
        //   match:
        //     System.Predicate`1，定义要搜索的元素的条件。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果找到一个其中所有元素均与指定谓词定义的条件匹配的 System.Array，则为该数组；否则为一个空 System.Array。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。 - 或 - match 为 null。
        public static T[] FindAll(T[] array, Predicate match);
        //
        // 摘要:
        //     搜索与指定谓词所定义的条件相匹配的元素，并返回 System.Array 中从指定索引到最后一个元素的元素范围内第一个匹配项的从零开始的索引。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维 System.Array。
        //
        //   startIndex:
        //     从零开始的搜索的起始索引。
        //
        //   match:
        //     System.Predicate`1，定义要搜索的元素的条件。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果找到与 match 定义的条件相匹配的第一个元素，则为该元素的从零开始的索引；否则为 -1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。 - 或 - match 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     startIndex 超出了 array 的有效索引范围。
        public static int FindIndex(T[] array, int startIndex, Predicate match);
        //
        // 摘要:
        //     搜索与指定谓词所定义的条件相匹配的一个元素，并返回 System.Array 中从指定的索引开始、包含指定元素个数的元素范围内第一个匹配项的从零开始的索引。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维 System.Array。
        //
        //   startIndex:
        //     从零开始的搜索的起始索引。
        //
        //   count:
        //     要搜索的部分中的元素数。
        //
        //   match:
        //     System.Predicate`1，定义要搜索的元素的条件。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果找到与 match 定义的条件相匹配的第一个元素，则为该元素的从零开始的索引；否则为 -1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。 - 或 - match 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     startIndex 超出了 array 的有效索引范围。 - 或 - count 小于零。 - 或 - startIndex 和 count 指定的不是
        //     array 中的有效部分。
        public static int FindIndex(T[] array, int startIndex, int count, Predicate match);
        //
        // 摘要:
        //     搜索与指定谓词所定义的条件相匹配的元素，并返回整个 System.Array 中第一个匹配元素的从零开始的索引。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维 System.Array。
        //
        //   match:
        //     System.Predicate`1，定义要搜索的元素的条件。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果找到与 match 定义的条件相匹配的第一个元素，则为该元素的从零开始的索引；否则为 -1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。 - 或 - match 为 null。
        public static int FindIndex(T[] array, Predicate match);
        //
        // 摘要:
        //     搜索与指定谓词所定义的条件相匹配的元素，并返回整个 System.Array 中的最后一个匹配元素。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维 System.Array。
        //
        //   match:
        //     System.Predicate`1，定义要搜索的元素的条件。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果找到，则为与指定谓词所定义的条件相匹配的最后一个元素；否则为类型 T 的默认值。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。 - 或 - match 为 null。
        public static T FindLast(T[] array, Predicate match);
        //
        // 摘要:
        //     搜索与指定谓词所定义的条件相匹配的元素，并返回 System.Array 中包含指定元素个数、到指定索引结束的元素范围内最后一个匹配项的从零开始的索引。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维 System.Array。
        //
        //   startIndex:
        //     向后搜索的从零开始的起始索引。
        //
        //   count:
        //     要搜索的部分中的元素数。
        //
        //   match:
        //     System.Predicate`1，定义要搜索的元素的条件。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果找到与 match 定义的条件相匹配的最后一个元素，则为该元素的从零开始的索引；否则为 -1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。 - 或 - match 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     startIndex 超出了 array 的有效索引范围。 - 或 - count 小于零。 - 或 - startIndex 和 count 指定的不是
        //     array 中的有效部分。
        public static int FindLastIndex(T[] array, int startIndex, int count, Predicate match);
        //
        // 摘要:
        //     搜索与由指定谓词定义的条件相匹配的元素，并返回 System.Array 中从第一个元素到指定索引的元素范围内最后一个匹配项的从零开始的索引。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维 System.Array。
        //
        //   startIndex:
        //     向后搜索的从零开始的起始索引。
        //
        //   match:
        //     System.Predicate`1，定义要搜索的元素的条件。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果找到与 match 定义的条件相匹配的最后一个元素，则为该元素的从零开始的索引；否则为 -1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。 - 或 - match 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     startIndex 超出了 array 的有效索引范围。
        public static int FindLastIndex(T[] array, int startIndex, Predicate match);
        //
        // 摘要:
        //     搜索与指定谓词所定义的条件相匹配的元素，并返回整个 System.Array 中最后一个匹配元素的从零开始的索引。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维 System.Array。
        //
        //   match:
        //     System.Predicate`1，定义要搜索的元素的条件。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果找到与 match 定义的条件相匹配的最后一个元素，则为该元素的从零开始的索引；否则为 -1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。 - 或 - match 为 null。
        public static int FindLastIndex(T[] array, Predicate match);
        //
        // 摘要:
        //     对指定数组的每个元素执行指定操作。
        //
        // 参数:
        //   array:
        //     从零开始的一维 System.Array，要对其元素执行操作。
        //
        //   action:
        //     要对 array 的每个元素执行的 System.Action`1。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。 - 或 - action 为 null。
        public static void ForEach(T[] array, Action action);
        //
        // 摘要:
        //     搜索指定的对象，并返回 System.Array 中从指定索引开始包含指定个元素的这部分元素中第一个匹配项的索引。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维 System.Array。
        //
        //   value:
        //     要在 array 中查找的对象。
        //
        //   startIndex:
        //     从零开始的搜索的起始索引。 空数组中 0（零）为有效值。
        //
        //   count:
        //     要搜索的部分中的元素数。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果在 array 中从 startIndex 开始、包含 count 所指定的元素个数的这部分元素中，找到 value 的匹配项，则为第一个匹配项的从零开始的索引；否则为
        //     -1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     startIndex 超出了 array 的有效索引范围。 - 或 - count 小于零。 - 或 - startIndex 和 count 指定的不是
        //     array 中的有效部分。
        public static int IndexOf(T[] array, T value, int startIndex, int count);
        //
        // 摘要:
        //     搜索指定的对象，并返回 System.Array 中从指定索引到最后一个元素这部分元素中第一个匹配项的索引。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维 System.Array。
        //
        //   value:
        //     要在 array 中查找的对象。
        //
        //   startIndex:
        //     从零开始的搜索的起始索引。 空数组中 0（零）为有效值。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果在 array 中从 startIndex 到最后一个元素这部分元素中找到 value 的匹配项，则为第一个匹配项的从零开始的索引；否则为 -1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     startIndex 超出了 array 的有效索引范围。
        public static int IndexOf(T[] array, T value, int startIndex);
        //
        // 摘要:
        //     搜索指定的对象，并返回整个 System.Array 中第一个匹配项的索引。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维 System.Array。
        //
        //   value:
        //     要在 array 中查找的对象。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果在整个 array 中找到 value 的第一个匹配项，则为该项的从零开始的索引；否则为 -1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        public static int IndexOf(T[] array, T value);
        //
        // 摘要:
        //     搜索指定的对象，并返回一维 System.Array 中从指定索引到最后一个元素这部分元素中第一个匹配项的索引。
        //
        // 参数:
        //   array:
        //     要搜索的一维 System.Array。
        //
        //   value:
        //     要在 array 中查找的对象。
        //
        //   startIndex:
        //     搜索的起始索引。 空数组中 0（零）为有效值。
        //
        // 返回结果:
        //     如果在 array 中从 startIndex 到最后一个元素这部分元素中第一个与 value 匹配的项的索引；否则为该数组的下限减 1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     startIndex 超出了 array 的有效索引范围。
        //
        //   T:System.RankException:
        //     array 是多维的。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int IndexOf(Array array, object value, int startIndex);
        //
        // 摘要:
        //     搜索指定的对象，并返回整个一维 System.Array 中第一个匹配项的索引。
        //
        // 参数:
        //   array:
        //     要搜索的一维 System.Array。
        //
        //   value:
        //     要在 array 中查找的对象。
        //
        // 返回结果:
        //     如果在整个 array 中找到 value 的匹配项，则为第一个匹配项的索引；否则为该数组的下限减 1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.RankException:
        //     array 是多维的。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int IndexOf(Array array, object value);
        //
        // 摘要:
        //     搜索指定的对象，并返回一维 System.Array 中从指定索引开始包含指定个元素的这部分元素中第一个匹配项的索引。
        //
        // 参数:
        //   array:
        //     要搜索的一维 System.Array。
        //
        //   value:
        //     要在 array 中查找的对象。
        //
        //   startIndex:
        //     搜索的起始索引。 空数组中 0（零）为有效值。
        //
        //   count:
        //     要搜索的部分中的元素数。
        //
        // 返回结果:
        //     如果在 array 中从 startIndex 开始并且包含的元素个数为在 count 中指定的个数的这部分元素中找到 value 的匹配项，则为第一个匹配项的索引；否则为该数组的下限减
        //     1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     startIndex 超出了 array 的有效索引范围。 - 或 - count 小于零。 - 或 - startIndex 和 count 指定的不是
        //     array 中的有效部分。
        //
        //   T:System.RankException:
        //     array 是多维的。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        [SecuritySafeCritical]
        public static int IndexOf(Array array, object value, int startIndex, int count);
        //
        // 摘要:
        //     搜索指定的对象，并返回一维 System.Array 中到指定索引为止包含指定个元素的这部分元素中最后一个匹配项的索引。
        //
        // 参数:
        //   array:
        //     要搜索的一维 System.Array。
        //
        //   value:
        //     要在 array 中查找的对象。
        //
        //   startIndex:
        //     向后搜索的起始索引。
        //
        //   count:
        //     要搜索的部分中的元素数。
        //
        // 返回结果:
        //     如果在 array 中到 startIndex 为止并且包含的元素个数为在 count 中指定的个数的这部分元素中找到 value 的匹配项，则为最后一个匹配项的索引；否则为该数组的下限减
        //     1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     startIndex 超出了 array 的有效索引范围。 - 或 - count 小于零。 - 或 - startIndex 和 count 指定的不是
        //     array 中的有效部分。
        //
        //   T:System.RankException:
        //     array 是多维的。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        [SecuritySafeCritical]
        public static int LastIndexOf(Array array, object value, int startIndex, int count);
        //
        // 摘要:
        //     搜索指定的对象，并返回一维 System.Array 中从第一个元素到指定索引这部分元素中最后一个匹配项的索引。
        //
        // 参数:
        //   array:
        //     要搜索的一维 System.Array。
        //
        //   value:
        //     要在 array 中查找的对象。
        //
        //   startIndex:
        //     向后搜索的起始索引。
        //
        // 返回结果:
        //     如果在 array 中从第一个元素到 startIndex 这部分元素中找到 value 的匹配项，则为最后一个匹配项的索引；否则为该数组的下限减 1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     startIndex 超出了 array 的有效索引范围。
        //
        //   T:System.RankException:
        //     array 是多维的。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int LastIndexOf(Array array, object value, int startIndex);
        //
        // 摘要:
        //     搜索指定的对象，并返回 System.Array 中从第一个元素到指定索引这部分元素中最后一个匹配项的索引。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维 System.Array。
        //
        //   value:
        //     要在 array 中查找的对象。
        //
        //   startIndex:
        //     向后搜索的从零开始的起始索引。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果在 array 中从第一个元素到 startIndex 这部分元素中找到 value 的匹配项，则为最后一个匹配项的从零开始的索引；否则为 -1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     startIndex 超出了 array 的有效索引范围。
        public static int LastIndexOf(T[] array, T value, int startIndex);
        //
        // 摘要:
        //     搜索指定的对象，并返回 System.Array 中到指定索引为止包含指定个元素的这部分元素中最后一个匹配项的索引。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维 System.Array。
        //
        //   value:
        //     要在 array 中查找的对象。
        //
        //   startIndex:
        //     向后搜索的从零开始的起始索引。
        //
        //   count:
        //     要搜索的部分中的元素数。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果在 array 中到 startIndex 为止、包含 count 所指定的元素个数的这部分元素中，找到 value 的匹配项，则为最后一个匹配项的从零开始的索引；否则为
        //     -1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     startIndex 超出了 array 的有效索引范围。 - 或 - count 小于零。 - 或 - startIndex 和 count 指定的不是
        //     array 中的有效部分。
        public static int LastIndexOf(T[] array, T value, int startIndex, int count);
        //
        // 摘要:
        //     搜索指定的对象，并返回整个 System.Array 中最后一个匹配项的索引。
        //
        // 参数:
        //   array:
        //     要搜索的从零开始的一维 System.Array。
        //
        //   value:
        //     要在 array 中查找的对象。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果在整个 array 中找到 value 的匹配项，则为最后一个匹配项的从零开始的索引；否则为 -1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        public static int LastIndexOf(T[] array, T value);
        //
        // 摘要:
        //     搜索指定的对象，并返回整个一维 System.Array 中最后一个匹配项的索引。
        //
        // 参数:
        //   array:
        //     要搜索的一维 System.Array。
        //
        //   value:
        //     要在 array 中查找的对象。
        //
        // 返回结果:
        //     如果在整个 array 中找到 value 的匹配项，则为最后一个匹配项的索引；否则为该数组的下限减 1。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.RankException:
        //     array 是多维的。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int LastIndexOf(Array array, object value);
        //
        // 摘要:
        //     将数组的元素数更改为指定的新大小。
        //
        // 参数:
        //   array:
        //     要调整大小的一维数组，该数组从零开始；如果为 null 则新建具有指定大小的数组。
        //
        //   newSize:
        //     新数组的大小。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 异常:
        //   T:System.ArgumentOutOfRangeException:
        //     newSize 小于零。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static void Resize(ref T[] array, int newSize);
        //
        // 摘要:
        //     反转一维 System.Array 中某部分元素的元素顺序。
        //
        // 参数:
        //   array:
        //     要反转的一维 System.Array。
        //
        //   index:
        //     要反转的部分的起始索引。
        //
        //   length:
        //     要反转的部分中的元素数。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.RankException:
        //     array 是多维的。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 小于 array 的下限。 - 或 - length 小于零。
        //
        //   T:System.ArgumentException:
        //     index 和 length 不指定 array 中的有效范围。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        [SecuritySafeCritical]
        public static void Reverse(Array array, int index, int length);
        //
        // 摘要:
        //     反转整个一维 System.Array 中元素的顺序。
        //
        // 参数:
        //   array:
        //     要反转的一维 System.Array。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.RankException:
        //     array 是多维的。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        public static void Reverse(Array array);
        //
        // 摘要:
        //     使用 System.Array 中每个元素的 System.IComparable 实现，对一维 System.Array 中某部分元素进行排序。
        //
        // 参数:
        //   array:
        //     要排序的一维 System.Array。
        //
        //   index:
        //     排序范围的起始索引。
        //
        //   length:
        //     排序范围内的元素数。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.RankException:
        //     array 是多维的。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 小于 array 的下限。 - 或 - length 小于零。
        //
        //   T:System.ArgumentException:
        //     index 和 length 不指定 array 中的有效范围。
        //
        //   T:System.InvalidOperationException:
        //     array 中的一个或多个元素未实现 System.IComparable 接口。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        public static void Sort(Array array, int index, int length);
        //
        // 摘要:
        //     基于第一个 System.Array 中的关键字，使用指定的 System.Collections.IComparer，对两个一维 System.Array
        //     对象（一个包含关键字，另一个包含对应的项）进行排序。
        //
        // 参数:
        //   keys:
        //     一维 System.Array，它包含要排序的关键字。
        //
        //   items:
        //     一维 System.Array，其中包含与 keysSystem.Array 中每个键对应的项。 - 或 - null 则只对 keysSystem.Array
        //     进行排序。
        //
        //   comparer:
        //     比较元素时要使用的 System.Collections.IComparer 实现。 - 或 - 若为 null，则使用每个元素的 System.IComparable
        //     实现。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     keys 为 null。
        //
        //   T:System.RankException:
        //     keys System.Array 是多维的。 - 或 - itemsSystem.Array 是多维的。
        //
        //   T:System.ArgumentException:
        //     items 不是 null，并且 keys 的长度大于 items 的长度。 - 或 - comparer 的实现导致排序时出现错误。 例如，将某个项与其自身进行比较时，comparer
        //     可能不返回 0。
        //
        //   T:System.InvalidOperationException:
        //     comparer 为 null，并且 keysSystem.Array 中的一个或多个元素不实现 System.IComparable 接口。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        public static void Sort(Array keys, Array items, IComparer comparer);
        //
        // 摘要:
        //     使用指定的 System.Collections.IComparer，对一维 System.Array 中的元素进行排序。
        //
        // 参数:
        //   array:
        //     要排序的一维 System.Array。
        //
        //   comparer:
        //     比较元素时要使用的 System.Collections.IComparer 实现。 - 或 - 若为 null，则使用每个元素的 System.IComparable
        //     实现。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.RankException:
        //     array 是多维的。
        //
        //   T:System.InvalidOperationException:
        //     comparer 为 null，array 中的一个或多个元素不实现 System.IComparable 接口。
        //
        //   T:System.ArgumentException:
        //     comparer 的实现导致排序时出现错误。 例如，将某个项与其自身进行比较时，comparer 可能不返回 0。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        public static void Sort(Array array, IComparer comparer);
        //
        // 摘要:
        //     基于第一个 System.Array 中的关键字，使用每个关键字的 System.IComparable 实现，对两个一维 System.Array 对象（一个包含关键字，另一个包含对应的项）的部分元素进行排序。
        //
        // 参数:
        //   keys:
        //     一维 System.Array，它包含要排序的关键字。
        //
        //   items:
        //     一维 System.Array，其中包含与 keysSystem.Array 中每个键对应的项。 - 或 - null 则只对 keysSystem.Array
        //     进行排序。
        //
        //   index:
        //     排序范围的起始索引。
        //
        //   length:
        //     排序范围内的元素数。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     keys 为 null。
        //
        //   T:System.RankException:
        //     keys System.Array 是多维的。 - 或 - itemsSystem.Array 是多维的。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 小于 keys 的下限。 - 或 - length 小于零。
        //
        //   T:System.ArgumentException:
        //     items 不是 null，并且 keys 的长度大于 items 的长度。 - 或 - index 和 length 未指定 keysSystem.Array
        //     中的有效范围。 - 或 - items 不为 null，并且 index 和 length 未在 itemsSystem.Array 中指定有效范围。
        //
        //   T:System.InvalidOperationException:
        //     keys System.Array 中的一个或多个元素未实现 System.IComparable 接口。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        public static void Sort(Array keys, Array items, int index, int length);
        //
        // 摘要:
        //     使用 System.Array 的每个元素的 System.IComparable`1 泛型接口实现，对整个 System.Array 中的元素进行排序。
        //
        // 参数:
        //   array:
        //     要排序的从零开始的一维 System.Array。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.InvalidOperationException:
        //     array 中的一个或多个元素未实现 System.IComparable`1 泛型接口。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        public static void Sort(T[] array);
        //
        // 摘要:
        //     基于第一个 System.Array 中的关键字，使用每个关键字的 System.IComparable 实现，对两个一维 System.Array 对象（一个包含关键字，另一个包含对应的项）进行排序。
        //
        // 参数:
        //   keys:
        //     一维 System.Array，它包含要排序的关键字。
        //
        //   items:
        //     一维 System.Array，其中包含与 keysSystem.Array 中每个键对应的项。 - 或 - null 则只对 keysSystem.Array
        //     进行排序。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     keys 为 null。
        //
        //   T:System.RankException:
        //     keys System.Array 是多维的。 - 或 - itemsSystem.Array 是多维的。
        //
        //   T:System.ArgumentException:
        //     items 不是 null，并且 keys 的长度大于 items 的长度。
        //
        //   T:System.InvalidOperationException:
        //     keys System.Array 中的一个或多个元素未实现 System.IComparable 接口。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        public static void Sort(Array keys, Array items);
        //
        // 摘要:
        //     使用 System.Array 中每个元素的 System.IComparable 实现，对整个一维 System.Array 中的元素进行排序。
        //
        // 参数:
        //   array:
        //     要排序的一维 System.Array。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.RankException:
        //     array 是多维的。
        //
        //   T:System.InvalidOperationException:
        //     array 中的一个或多个元素未实现 System.IComparable 接口。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        public static void Sort(Array array);
        //
        // 摘要:
        //     基于第一个 System.Array 中的关键字，使用每个关键字的 System.IComparable`1 泛型接口实现，对两个 System.Array
        //     对象（一个包含关键字，另一个包含对应的项）进行排序。
        //
        // 参数:
        //   keys:
        //     从零开始的一维 System.Array，它包含要排序的关键字。
        //
        //   items:
        //     从零开始的一维 System.Array，其中包含与 keys 中的关键字对应的项；如果为 null，则只对 keys 进行排序。
        //
        // 类型参数:
        //   TKey:
        //     关键字数组元素的类型。
        //
        //   TValue:
        //     项数组元素的类型。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     keys 为 null。
        //
        //   T:System.ArgumentException:
        //     items 不是 null，且 keys 的下限与 items 的下限不匹配。 - 或 - items 不是 null，并且 keys 的长度大于 items
        //     的长度。
        //
        //   T:System.InvalidOperationException:
        //     keys System.Array 中的一个或多个元素未实现 System.IComparable`1 泛型接口。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        public static void Sort(TKey[] keys, TValue[] items);
        //
        // 摘要:
        //     使用指定的 System.Collections.IComparer，对一维 System.Array 的部分元素进行排序。
        //
        // 参数:
        //   array:
        //     要排序的一维 System.Array。
        //
        //   index:
        //     排序范围的起始索引。
        //
        //   length:
        //     排序范围内的元素数。
        //
        //   comparer:
        //     比较元素时要使用的 System.Collections.IComparer 实现。 - 或 - 若为 null，则使用每个元素的 System.IComparable
        //     实现。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.RankException:
        //     array 是多维的。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 小于 array 的下限。 - 或 - length 小于零。
        //
        //   T:System.ArgumentException:
        //     index 和 length 不指定 array 中的有效范围。 - 或 - comparer 的实现导致排序时出现错误。 例如，将某个项与其自身进行比较时，comparer
        //     可能不返回 0。
        //
        //   T:System.InvalidOperationException:
        //     comparer 为 null，array 中的一个或多个元素不实现 System.IComparable 接口。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        public static void Sort(Array array, int index, int length, IComparer comparer);
        //
        // 摘要:
        //     使用 System.Array 的每个元素的 System.IComparable`1 泛型接口实现，对 System.Array 中某个元素范围内的元素进行排序。
        //
        // 参数:
        //   array:
        //     要排序的从零开始的一维 System.Array。
        //
        //   index:
        //     排序范围的起始索引。
        //
        //   length:
        //     排序范围内的元素数。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 小于 array 的下限。 - 或 - length 小于零。
        //
        //   T:System.ArgumentException:
        //     index 和 length 不指定 array 中的有效范围。
        //
        //   T:System.InvalidOperationException:
        //     array 中的一个或多个元素未实现 System.IComparable`1 泛型接口。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        public static void Sort(T[] array, int index, int length);
        //
        // 摘要:
        //     基于第一个 System.Array 中的关键字，使用每个关键字的 System.IComparable`1 泛型接口实现，对两个 System.Array
        //     对象（一个包含关键字，另一个包含对应的项）的部分元素进行排序。
        //
        // 参数:
        //   keys:
        //     从零开始的一维 System.Array，它包含要排序的关键字。
        //
        //   items:
        //     从零开始的一维 System.Array，其中包含与 keys 中的关键字对应的项；如果为 null，则只对 keys 进行排序。
        //
        //   index:
        //     排序范围的起始索引。
        //
        //   length:
        //     排序范围内的元素数。
        //
        // 类型参数:
        //   TKey:
        //     关键字数组元素的类型。
        //
        //   TValue:
        //     项数组元素的类型。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     keys 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 小于 keys 的下限。 - 或 - length 小于零。
        //
        //   T:System.ArgumentException:
        //     items 不是 null，且 keys 的下限与 items 的下限不匹配。 - 或 - items 不是 null，并且 keys 的长度大于 items
        //     的长度。 - 或 - index 和 length 未指定 keysSystem.Array 中的有效范围。 - 或 - items 不为 null，并且
        //     index 和 length 未在 itemsSystem.Array 中指定有效范围。
        //
        //   T:System.InvalidOperationException:
        //     keys System.Array 中的一个或多个元素未实现 System.IComparable`1 泛型接口。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        public static void Sort(TKey[] keys, TValue[] items, int index, int length);
        //
        // 摘要:
        //     使用指定的 System.Collections.Generic.IComparer`1 泛型接口，对 System.Array 中的元素进行排序。
        //
        // 参数:
        //   array:
        //     要排序的从零开始的一维 System.Array
        //
        //   comparer:
        //     比较元素时使用的 System.Collections.Generic.IComparer`1 泛型接口实现；如果为 null，则使用每个元素的 System.IComparable`1
        //     泛型接口实现。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.InvalidOperationException:
        //     comparer 为 null，并且 array 中的一个或多个元素未实现 System.IComparable`1 泛型接口。
        //
        //   T:System.ArgumentException:
        //     comparer 的实现导致排序时出现错误。 例如，将某个项与其自身进行比较时，comparer 可能不返回 0。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        public static void Sort(T[] array, IComparer comparer);
        //
        // 摘要:
        //     基于第一个 System.Array 中的关键字，使用指定的 System.Collections.Generic.IComparer`1 泛型接口，对两个
        //     System.Array 对象（一个包含关键字，另一个包含对应的项）进行排序。
        //
        // 参数:
        //   keys:
        //     从零开始的一维 System.Array，它包含要排序的关键字。
        //
        //   items:
        //     从零开始的一维 System.Array，其中包含与 keys 中的关键字对应的项；如果为 null，则只对 keys 进行排序。
        //
        //   comparer:
        //     比较元素时使用的 System.Collections.Generic.IComparer`1 泛型接口实现；如果为 null，则使用每个元素的 System.IComparable`1
        //     泛型接口实现。
        //
        // 类型参数:
        //   TKey:
        //     关键字数组元素的类型。
        //
        //   TValue:
        //     项数组元素的类型。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     keys 为 null。
        //
        //   T:System.ArgumentException:
        //     items 不是 null，且 keys 的下限与 items 的下限不匹配。 - 或 - items 不是 null，并且 keys 的长度大于 items
        //     的长度。 - 或 - comparer 的实现导致排序时出现错误。 例如，将某个项与其自身进行比较时，comparer 可能不返回 0。
        //
        //   T:System.InvalidOperationException:
        //     comparer 为 null，并且 keysSystem.Array 中的一个或多个元素未实现 System.IComparable`1 泛型接口。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        public static void Sort(TKey[] keys, TValue[] items, IComparer comparer);
        //
        // 摘要:
        //     使用指定的 System.Collections.Generic.IComparer`1 泛型接口，对 System.Array 中某个元素范围内的元素进行排序。
        //
        // 参数:
        //   array:
        //     要排序的从零开始的一维 System.Array。
        //
        //   index:
        //     排序范围的起始索引。
        //
        //   length:
        //     排序范围内的元素数。
        //
        //   comparer:
        //     比较元素时使用的 System.Collections.Generic.IComparer`1 泛型接口实现；如果为 null，则使用每个元素的 System.IComparable`1
        //     泛型接口实现。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 小于 array 的下限。 - 或 - length 小于零。
        //
        //   T:System.ArgumentException:
        //     index 和 length 不指定 array 中的有效范围。 - 或 - comparer 的实现导致排序时出现错误。 例如，将某个项与其自身进行比较时，comparer
        //     可能不返回 0。
        //
        //   T:System.InvalidOperationException:
        //     comparer 为 null，并且 array 中的一个或多个元素未实现 System.IComparable`1 泛型接口。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        [SecuritySafeCritical]
        public static void Sort(T[] array, int index, int length, IComparer comparer);
        //
        // 摘要:
        //     基于第一个 System.Array 中的关键字，使用指定的 System.Collections.Generic.IComparer`1 泛型接口，对两个
        //     System.Array 对象（一个包含关键字，另一个包含对应的项）的部分元素进行排序。
        //
        // 参数:
        //   keys:
        //     从零开始的一维 System.Array，它包含要排序的关键字。
        //
        //   items:
        //     从零开始的一维 System.Array，其中包含与 keys 中的关键字对应的项；如果为 null，则只对 keys 进行排序。
        //
        //   index:
        //     排序范围的起始索引。
        //
        //   length:
        //     排序范围内的元素数。
        //
        //   comparer:
        //     比较元素时使用的 System.Collections.Generic.IComparer`1 泛型接口实现；如果为 null，则使用每个元素的 System.IComparable`1
        //     泛型接口实现。
        //
        // 类型参数:
        //   TKey:
        //     关键字数组元素的类型。
        //
        //   TValue:
        //     项数组元素的类型。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     keys 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 小于 keys 的下限。 - 或 - length 小于零。
        //
        //   T:System.ArgumentException:
        //     items 不是 null，且 keys 的下限与 items 的下限不匹配。 - 或 - items 不是 null，并且 keys 的长度大于 items
        //     的长度。 - 或 - index 和 length 未指定 keysSystem.Array 中的有效范围。 - 或 - items 不为 null，并且
        //     index 和 length 未在 itemsSystem.Array 中指定有效范围。 - 或 - comparer 的实现导致排序时出现错误。 例如，将某个项与其自身进行比较时，comparer
        //     可能不返回 0。
        //
        //   T:System.InvalidOperationException:
        //     comparer 为 null，并且 keysSystem.Array 中的一个或多个元素未实现 System.IComparable`1 泛型接口。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        [SecuritySafeCritical]
        public static void Sort(TKey[] keys, TValue[] items, int index, int length, IComparer comparer);
        //
        // 摘要:
        //     使用指定的 System.Comparison`1 对 System.Array 中的元素进行排序。
        //
        // 参数:
        //   array:
        //     要排序的从零开始的一维 System.Array。
        //
        //   comparison:
        //     比较元素时要使用的 System.Comparison`1。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。 - 或 - comparison 为 null。
        //
        //   T:System.ArgumentException:
        //     在排序过程中，comparison 的实现会导致错误。 例如，将某个项与其自身进行比较时，comparison 可能不返回 0。
        public static void Sort(T[] array, Comparison comparison);
        //
        // 摘要:
        //     基于第一个 System.Array 中的关键字，使用指定的 System.Collections.IComparer，对两个一维 System.Array
        //     对象（一个包含关键字，另一个包含对应的项）的部分元素进行排序。
        //
        // 参数:
        //   keys:
        //     一维 System.Array，它包含要排序的关键字。
        //
        //   items:
        //     一维 System.Array，其中包含与 keysSystem.Array 中每个键对应的项。 - 或 - null 则只对 keysSystem.Array
        //     进行排序。
        //
        //   index:
        //     排序范围的起始索引。
        //
        //   length:
        //     排序范围内的元素数。
        //
        //   comparer:
        //     比较元素时要使用的 System.Collections.IComparer 实现。 - 或 - 若为 null，则使用每个元素的 System.IComparable
        //     实现。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     keys 为 null。
        //
        //   T:System.RankException:
        //     keys System.Array 是多维的。 - 或 - itemsSystem.Array 是多维的。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 小于 keys 的下限。 - 或 - length 小于零。
        //
        //   T:System.ArgumentException:
        //     items 不是 null，且 keys 的下限与 items 的下限不匹配。 - 或 - items 不是 null，并且 keys 的长度大于 items
        //     的长度。 - 或 - index 和 length 未指定 keysSystem.Array 中的有效范围。 - 或 - items 不为 null，并且
        //     index 和 length 未在 itemsSystem.Array 中指定有效范围。 - 或 - comparer 的实现导致排序时出现错误。 例如，将某个项与其自身进行比较时，comparer
        //     可能不返回 0。
        //
        //   T:System.InvalidOperationException:
        //     comparer 为 null，并且 keysSystem.Array 中的一个或多个元素不实现 System.IComparable 接口。
        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
        [SecuritySafeCritical]
        public static void Sort(Array keys, Array items, int index, int length, IComparer comparer);
        //
        // 摘要:
        //     确定数组中的每个元素是否都与指定谓词定义的条件匹配。
        //
        // 参数:
        //   array:
        //     要对照条件进行检查的从零开始的一维 System.Array
        //
        //   match:
        //     System.Predicate`1 定义检查元素时要对照的条件。
        //
        // 类型参数:
        //   T:
        //     数组元素的类型。
        //
        // 返回结果:
        //     如果 array 中的每个元素都与指定谓词定义的条件匹配，则为 true；否则为 false。 如果数组中没有元素，则返回值为 true。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。 - 或 - match 为 null。
        public static bool TrueForAll(T[] array, Predicate match);
        //
        // 摘要:
        //     创建 System.Array 的浅表副本。
        //
        // 返回结果:
        //     System.Array 的浅表副本。
        public object Clone();
        //
        // 摘要:
        //     将当前一维 System.Array 的所有元素复制到指定的一维 System.Array 中（从指定的目标 System.Array 索引开始）。 索引指定为
        //     32 位整数。
        //
        // 参数:
        //   array:
        //     一维 System.Array，它是从当前 System.Array 复制的元素的目标位置。
        //
        //   index:
        //     一个 32 位整数，它表示 array 中复制开始处的索引。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 小于 array 的下限。
        //
        //   T:System.ArgumentException:
        //     array 是多维的。 - 或 - 源 System.Array 中的元素数目大于从 index 到目标 array 末尾之间的可用空间。
        //
        //   T:System.ArrayTypeMismatchException:
        //     无法自动将源 System.Array 的类型强制转换为目标 array 的类型。
        //
        //   T:System.RankException:
        //     源 System.Array 是多维的。
        //
        //   T:System.InvalidCastException:
        //     源 System.Array 中至少有一个元素无法强制转换为目标 array 的类型。
        public void CopyTo(Array array, int index);
        //
        // 摘要:
        //     将当前一维 System.Array 的所有元素复制到指定的一维 System.Array 中（从指定的目标 System.Array 索引开始）。 索引指定为
        //     64 位整数。
        //
        // 参数:
        //   array:
        //     一维 System.Array，它是从当前 System.Array 复制的元素的目标位置。
        //
        //   index:
        //     一个 64 位整数，它表示 array 中复制开始处的索引。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     array 为 null。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 超出了 array 的有效索引范围。
        //
        //   T:System.ArgumentException:
        //     array 是多维的。 - 或 - 源 System.Array 中的元素数目大于从 index 到目标 array 末尾之间的可用空间。
        //
        //   T:System.ArrayTypeMismatchException:
        //     无法自动将源 System.Array 的类型强制转换为目标 array 的类型。
        //
        //   T:System.RankException:
        //     源 System.Array 是多维的。
        //
        //   T:System.InvalidCastException:
        //     源 System.Array 中至少有一个元素无法强制转换为目标 array 的类型。
        [ComVisible(false)]
        public void CopyTo(Array array, long index);
        //
        // 摘要:
        //     返回 System.Array 的 System.Collections.IEnumerator。
        //
        // 返回结果:
        //     用于 System.Array 的 System.Collections.IEnumerator。
        public IEnumerator GetEnumerator();
        //
        // 摘要:
        //     获取一个 32 位整数，该整数表示 System.Array 的指定维中的元素数。
        //
        // 参数:
        //   dimension:
        //     System.Array 的从零开始的维度，其长度需要确定。
        //
        // 返回结果:
        //     一个 32 位整数，它表示指定维中的元素数。
        //
        // 异常:
        //   T:System.IndexOutOfRangeException:
        //     dimension 小于零。 - 或 - dimension 等于或大于 System.Array.Rank。
        [SecuritySafeCritical]
        public int GetLength(int dimension);
        //
        // 摘要:
        //     获取一个 64 位整数，该整数表示 System.Array 的指定维中的元素数。
        //
        // 参数:
        //   dimension:
        //     System.Array 的从零开始的维度，其长度需要确定。
        //
        // 返回结果:
        //     一个 64 位整数，它表示指定维中的元素数。
        //
        // 异常:
        //   T:System.IndexOutOfRangeException:
        //     dimension 小于零。 - 或 - dimension 等于或大于 System.Array.Rank。
        [ComVisible(false)]
        public long GetLongLength(int dimension);
        //
        // 摘要:
        //     获取 System.Array 中指定维度的下限。
        //
        // 参数:
        //   dimension:
        //     System.Array 的从零开始的维度，其下限需要确定。
        //
        // 返回结果:
        //     System.Array 中指定维度的下限。
        //
        // 异常:
        //   T:System.IndexOutOfRangeException:
        //     dimension 小于零。 - 或 - dimension 等于或大于 System.Array.Rank。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [SecuritySafeCritical]
        public int GetLowerBound(int dimension);
        //
        // 摘要:
        //     获取 System.Array 的指定维度的上限。
        //
        // 参数:
        //   dimension:
        //     System.Array 的从零开始的维度，其上限需要确定。
        //
        // 返回结果:
        //     System.Array 中的指定维度的上限。
        //
        // 异常:
        //   T:System.IndexOutOfRangeException:
        //     dimension 小于零。 - 或 - dimension 等于或大于 System.Array.Rank。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [SecuritySafeCritical]
        public int GetUpperBound(int dimension);
        //
        // 摘要:
        //     获取多维 System.Array 中指定位置的值。 索引指定为一个 64 位整数数组。
        //
        // 参数:
        //   indices:
        //     64 位整数的一维数组，它表示用于指定要获取的 System.Array 元素的位置的索引。
        //
        // 返回结果:
        //     多维 System.Array 中指定位置的值。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     indices 为 null。
        //
        //   T:System.ArgumentException:
        //     当前 System.Array 中的维数不等于 indices 中的元素数。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     indices 中的任何元素都超出当前 System.Array 的对应维度的有效索引的范围。
        [ComVisible(false)]
        public object GetValue(params long[] indices);
        //
        // 摘要:
        //     获取三维 System.Array 中指定位置的值。 索引指定为 64 位整数。
        //
        // 参数:
        //   index1:
        //     一个 64 位整数，它表示要获取的 System.Array 元素的第一维索引。
        //
        //   index2:
        //     一个 64 位整数，它表示要获取的 System.Array 元素的第二维索引。
        //
        //   index3:
        //     一个 64 位整数，它表示要获取的 System.Array 元素的第三维索引。
        //
        // 返回结果:
        //     三维 System.Array 中指定位置的值。
        //
        // 异常:
        //   T:System.ArgumentException:
        //     当前的 System.Array 不是正好有三维。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index1 或 index2 或 index3 超出当前 System.Array 的对应维度的有效索引的范围。
        [ComVisible(false)]
        public object GetValue(long index1, long index2, long index3);
        //
        // 摘要:
        //     获取多维 System.Array 中指定位置的值。 索引指定为一个 32 位整数数组。
        //
        // 参数:
        //   indices:
        //     32 位整数的一维数组，它表示用于指定要获取的 System.Array 元素的位置的索引。
        //
        // 返回结果:
        //     多维 System.Array 中指定位置的值。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     indices 为 null。
        //
        //   T:System.ArgumentException:
        //     当前 System.Array 中的维数不等于 indices 中的元素数。
        //
        //   T:System.IndexOutOfRangeException:
        //     indices 中的任何元素都超出当前 System.Array 的对应维度的有效索引的范围。
        [SecuritySafeCritical]
        public object GetValue(params int[] indices);
        //
        // 摘要:
        //     获取一维 System.Array 中指定位置的值。 索引指定为 32 位整数。
        //
        // 参数:
        //   index:
        //     一个 32 位整数，它表示要获取的 System.Array 元素的位置。
        //
        // 返回结果:
        //     一维 System.Array 中指定位置的值。
        //
        // 异常:
        //   T:System.ArgumentException:
        //     当前的 System.Array 不是正好有一维。
        //
        //   T:System.IndexOutOfRangeException:
        //     index 超出当前 System.Array 的有效索引的范围。
        [SecuritySafeCritical]
        public object GetValue(int index);
        //
        // 摘要:
        //     获取二维 System.Array 中指定位置的值。 索引指定为 32 位整数。
        //
        // 参数:
        //   index1:
        //     一个 32 位整数，它表示要获取的 System.Array 元素的第一维索引。
        //
        //   index2:
        //     一个 32 位整数，它表示要获取的 System.Array 元素的第二维索引。
        //
        // 返回结果:
        //     二维 System.Array 中指定位置的值。
        //
        // 异常:
        //   T:System.ArgumentException:
        //     当前的 System.Array 不是正好有两维。
        //
        //   T:System.IndexOutOfRangeException:
        //     index1 或 index2 超出当前 System.Array 的对应维度的有效索引的范围。
        [SecuritySafeCritical]
        public object GetValue(int index1, int index2);
        //
        // 摘要:
        //     获取三维 System.Array 中指定位置的值。 索引指定为 32 位整数。
        //
        // 参数:
        //   index1:
        //     一个 32 位整数，它表示要获取的 System.Array 元素的第一维索引。
        //
        //   index2:
        //     一个 32 位整数，它表示要获取的 System.Array 元素的第二维索引。
        //
        //   index3:
        //     一个 32 位整数，它表示要获取的 System.Array 元素的第三维索引。
        //
        // 返回结果:
        //     三维 System.Array 中指定位置的值。
        //
        // 异常:
        //   T:System.ArgumentException:
        //     当前的 System.Array 不是正好有三维。
        //
        //   T:System.IndexOutOfRangeException:
        //     index1 或 index2 或 index3 超出当前 System.Array 的对应维度的有效索引的范围。
        [SecuritySafeCritical]
        public object GetValue(int index1, int index2, int index3);
        //
        // 摘要:
        //     获取二维 System.Array 中指定位置的值。 索引指定为 64 位整数。
        //
        // 参数:
        //   index1:
        //     一个 64 位整数，它表示要获取的 System.Array 元素的第一维索引。
        //
        //   index2:
        //     一个 64 位整数，它表示要获取的 System.Array 元素的第二维索引。
        //
        // 返回结果:
        //     二维 System.Array 中指定位置的值。
        //
        // 异常:
        //   T:System.ArgumentException:
        //     当前的 System.Array 不是正好有两维。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index1 或 index2 超出当前 System.Array 的对应维度的有效索引的范围。
        [ComVisible(false)]
        public object GetValue(long index1, long index2);
        //
        // 摘要:
        //     获取一维 System.Array 中指定位置的值。 索引指定为 64 位整数。
        //
        // 参数:
        //   index:
        //     一个 64 位整数，它表示要获取的 System.Array 元素的位置。
        //
        // 返回结果:
        //     一维 System.Array 中指定位置的值。
        //
        // 异常:
        //   T:System.ArgumentException:
        //     当前的 System.Array 不是正好有一维。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 超出当前 System.Array 的有效索引的范围。
        [ComVisible(false)]
        public object GetValue(long index);
        //
        // 摘要:
        //     通过调用值类型的默认构造函数，初始化值类型 System.Array 的每一个元素。
        [SecuritySafeCritical]
        public void Initialize();
        //
        // 摘要:
        //     将某值设置给二维 System.Array 中指定位置的元素。 索引指定为 32 位整数。
        //
        // 参数:
        //   value:
        //     指定元素的新值。
        //
        //   index1:
        //     一个 32 位整数，它表示要设置的 System.Array 元素的第一维索引。
        //
        //   index2:
        //     一个 32 位整数，它表示要设置的 System.Array 元素的第二维索引。
        //
        // 异常:
        //   T:System.ArgumentException:
        //     当前的 System.Array 不是正好有两维。
        //
        //   T:System.InvalidCastException:
        //     value 不能强制转换为当前 System.Array 的元素类型。
        //
        //   T:System.IndexOutOfRangeException:
        //     index1 或 index2 超出当前 System.Array 的对应维度的有效索引的范围。
        [SecuritySafeCritical]
        public void SetValue(object value, int index1, int index2);
        //
        // 摘要:
        //     将某值设置给三维 System.Array 中指定位置的元素。 索引指定为 32 位整数。
        //
        // 参数:
        //   value:
        //     指定元素的新值。
        //
        //   index1:
        //     一个 32 位整数，它表示要设置的 System.Array 元素的第一维索引。
        //
        //   index2:
        //     一个 32 位整数，它表示要设置的 System.Array 元素的第二维索引。
        //
        //   index3:
        //     一个 32 位整数，它表示要设置的 System.Array 元素的第三维索引。
        //
        // 异常:
        //   T:System.ArgumentException:
        //     当前的 System.Array 不是正好有三维。
        //
        //   T:System.InvalidCastException:
        //     value 不能强制转换为当前 System.Array 的元素类型。
        //
        //   T:System.IndexOutOfRangeException:
        //     index1 或 index2 或 index3 超出当前 System.Array 的对应维度的有效索引的范围。
        [SecuritySafeCritical]
        public void SetValue(object value, int index1, int index2, int index3);
        //
        // 摘要:
        //     将某值设置给多维 System.Array 中指定位置的元素。 索引指定为一个 32 位整数数组。
        //
        // 参数:
        //   value:
        //     指定元素的新值。
        //
        //   indices:
        //     32 位整数的一维数组，它表示用于指定要设置的元素的位置的索引。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     indices 为 null。
        //
        //   T:System.ArgumentException:
        //     当前 System.Array 中的维数不等于 indices 中的元素数。
        //
        //   T:System.InvalidCastException:
        //     value 不能强制转换为当前 System.Array 的元素类型。
        //
        //   T:System.IndexOutOfRangeException:
        //     indices 中的任何元素都超出当前 System.Array 的对应维度的有效索引的范围。
        [SecuritySafeCritical]
        public void SetValue(object value, params int[] indices);
        //
        // 摘要:
        //     将某值设置给一维 System.Array 中指定位置的元素。 索引指定为 64 位整数。
        //
        // 参数:
        //   value:
        //     指定元素的新值。
        //
        //   index:
        //     一个 64 位整数，它表示要设置的 System.Array 元素的位置。
        //
        // 异常:
        //   T:System.ArgumentException:
        //     当前的 System.Array 不是正好有一维。
        //
        //   T:System.InvalidCastException:
        //     value 不能强制转换为当前 System.Array 的元素类型。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index 超出当前 System.Array 的有效索引的范围。
        [ComVisible(false)]
        public void SetValue(object value, long index);
        //
        // 摘要:
        //     将某值设置给二维 System.Array 中指定位置的元素。 索引指定为 64 位整数。
        //
        // 参数:
        //   value:
        //     指定元素的新值。
        //
        //   index1:
        //     一个 64 位整数，它表示要设置的 System.Array 元素的第一维索引。
        //
        //   index2:
        //     一个 64 位整数，它表示要设置的 System.Array 元素的第二维索引。
        //
        // 异常:
        //   T:System.ArgumentException:
        //     当前的 System.Array 不是正好有两维。
        //
        //   T:System.InvalidCastException:
        //     value 不能强制转换为当前 System.Array 的元素类型。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index1 或 index2 超出当前 System.Array 的对应维度的有效索引的范围。
        [ComVisible(false)]
        public void SetValue(object value, long index1, long index2);
        //
        // 摘要:
        //     将某值设置给三维 System.Array 中指定位置的元素。 索引指定为 64 位整数。
        //
        // 参数:
        //   value:
        //     指定元素的新值。
        //
        //   index1:
        //     一个 64 位整数，它表示要设置的 System.Array 元素的第一维索引。
        //
        //   index2:
        //     一个 64 位整数，它表示要设置的 System.Array 元素的第二维索引。
        //
        //   index3:
        //     一个 64 位整数，它表示要设置的 System.Array 元素的第三维索引。
        //
        // 异常:
        //   T:System.ArgumentException:
        //     当前的 System.Array 不是正好有三维。
        //
        //   T:System.InvalidCastException:
        //     value 不能强制转换为当前 System.Array 的元素类型。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     index1 或 index2 或 index3 超出当前 System.Array 的对应维度的有效索引的范围。
        [ComVisible(false)]
        public void SetValue(object value, long index1, long index2, long index3);
        //
        // 摘要:
        //     将某值设置给一维 System.Array 中指定位置的元素。 索引指定为 32 位整数。
        //
        // 参数:
        //   value:
        //     指定元素的新值。
        //
        //   index:
        //     一个 32 位整数，它表示要设置的 System.Array 元素的位置。
        //
        // 异常:
        //   T:System.ArgumentException:
        //     当前的 System.Array 不是正好有一维。
        //
        //   T:System.InvalidCastException:
        //     value 不能强制转换为当前 System.Array 的元素类型。
        //
        //   T:System.IndexOutOfRangeException:
        //     index 超出当前 System.Array 的有效索引的范围。
        [SecuritySafeCritical]
        public void SetValue(object value, int index);
        //
        // 摘要:
        //     将某值设置给多维 System.Array 中指定位置的元素。 索引指定为一个 64 位整数数组。
        //
        // 参数:
        //   value:
        //     指定元素的新值。
        //
        //   indices:
        //     64 位整数的一维数组，它表示用于指定要设置的元素的位置的索引。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     indices 为 null。
        //
        //   T:System.ArgumentException:
        //     当前 System.Array 中的维数不等于 indices 中的元素数。
        //
        //   T:System.InvalidCastException:
        //     value 不能强制转换为当前 System.Array 的元素类型。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     indices 中的任何元素都超出当前 System.Array 的对应维度的有效索引的范围。
        [ComVisible(false)]
        public void SetValue(object value, params long[] indices);
    }
}

2、

2.返回顶部

 

3.返回顶部

 

4.返回顶部

 

5.返回顶部

 

 

6.返回顶部

 

作者：ylbtech 出处：http://ylbtech.cnblogs.com/ 本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。