《随笔三十八》——C#中的 “ 解析Array类 中的属性与方法”

目录

Property

Array.ICollection.Count：

Array.Length 

 Array.Rank

Method

Array.BinarySearch （静态方法）

Array.Clear：

Array.Clone 

Array.Copy

Array.CopyTo

Array.CreateInstance

Array.Exists

Array.Find

Array.GetLength

Array.GetValue

Array.IndexOf

Array.GetLowerBound

Array.GetUpperBound

Array.LastIndexOf

Array.Resize

Array.Reverse

Array.SetValue

Array.Sort

---

点击进入官网了解 Array 更多成员详情信息

---

Propertys

---

Array.ICollection.Count：

获取 Array 中包含的元素的个数。

int System.Collections.ICollection.Count { get; }

Array.Length 

获取 Array 的中所有的元素个数

public int Length { get; }

 Array.Rank

获取 Array 的秩（维数）。 例如，一维数组返回 1，二维数组返回 2，依次类推。

public int Rank { get; }

 static void Main(string[] args)
        {
            int[] array1 = new int[10];
            int[,] array2 = new int[10, 3];
            int[,,] array3 = new int[10, 3,3];

            Console.WriteLine("{0}: {1} 维数组", array1.ToString(), array1.Rank);
            Console.WriteLine("{0}: {1} 维数组", array2.ToString(), array2.Rank);
            Console.WriteLine("{0}: {1} 维数组", array3.ToString(), array3.Rank);
        }

输出：
System.Int32[]: 1 维数组
System.Int32[,]: 2 维数组
System.Int32[,,]: 3 维数组

---

Methods

---

Array.BinarySearch （静态方法）

该方法有很多重载形式

public static int BinarySearch (Array array, object value);

• 在 array 数组中搜索 一个 名为 value 的值。
• 在 array 中允许重复元素。 如果Array包含多个等于 value 的元素，则该方法仅返回其中一个匹配项的索引，而不一定返回第一个匹配项的索引。
• null 总是可以与任何其他引用类型进行比较; 因此，与null的比较不会产生异常。
• 此方法为 O (log n) 操作，其中n是Length的array。
• 如果 参数 array 为 null。 抛出 ArgumentNullException
• 如果参数 array 是多维的。抛出  RankException
• 如果参数 value 的类型与 array 的元素不兼容。抛出 ArgumentException
• value 不实现 IComparable 接口，并且搜索遇到不实现 IComparable 接口的元素。抛出 InvalidOperationException

如果找到 value，那么返回 该 value 在数组中 的索引；否则为负整数。（具体看代码）

• 如果找不到的 value 是小于该数组中的所有元素，那么返回的索引值是该数组中已排序的元素下标为 0  的位置。
• 如果找不到的 value 是大于该数组中的所有元素， 那么返回索引值是 该数组中已排序的元素的最后一个元素下标值 + 1；
• 如果找不到的 value 刚好即不大于所有元素也不小于所有元素，那么返回的是数组中第一个 比 value 大的元素的索引值。
•  如果使用非排序数组调用此方法，则返回值可能不正确，并且可能返回负数，就算该数组中存在 value 也会返回负数。

       static void Main(string[] args)
        {          
            Array myIntArray = Array.CreateInstance(typeof(Int32), 5);
            myIntArray.SetValue(8, 0);
            myIntArray.SetValue(2, 1);
            myIntArray.SetValue(6, 2);
            myIntArray.SetValue(3, 3);
            myIntArray.SetValue(7, 4);
           Array.Sort(myIntArray); //想使用 BinarySearch 方法查找元素，最好使用 Sort 方法对元素进行排序,否则会出现意外结果
            foreach (var tt in myIntArray)
            {
                WriteLine(tt);
            }

            object locationValue = 1; 
            int myIndex1 = Array.BinarySearch(myIntArray, locationValue);
            if (myIndex1 < 0)
            {
                WriteLine($"找不到该对象{locationValue}，下一个索引位置是{~myIndex1}");
            }
            else
            {
                WriteLine($"找到该对象，为数字{myIntArray}， 在数组的索引位置{myIndex1}");
            }
            WriteLine();

            object myObjectEven = 25; 
            int myIndex = Array.BinarySearch(myIntArray, myObjectEven);
            if (myIndex < 0)
            {            
                WriteLine($"找不到该对象{myObjectEven}，下一个索引位置是{~myIndex}");
            }
            else
            {             
                WriteLine($"找到该对象，为数字{myIntArray}， 在数组的索引位置{myIndex}");
            }
            WriteLine();


            object sValue = 4;
            int myIndex4 = Array.BinarySearch(myIntArray, sValue);
            if (myIndex4 < 0)
            {
                WriteLine($"找不到该对象{sValue}，下一个索引位置是{~myIndex4}");
            }
            else
            {
                WriteLine($"找到该对象，为数字{sValue}， 在数组的索引位置{myIndex4}");
            }
            WriteLine();


            object searchValue = 6; 
            int myIndex3 = Array.BinarySearch(myIntArray, searchValue);
            if (myIndex3 < 0)
            {
                WriteLine($"找不到该对象{searchValue}，下一个索引位置是{~myIndex3}");
            }
            else
            {
                WriteLine($"找到该对象，为数字{searchValue}， 在数组的索引位置{myIndex3}");
            }
            WriteLine();

Array.Clear：

public static void Clear (Array array, int index, int length);

• 从 名为 array 数组中的 index 处的位置开始清空 length 个 元素类型。被清空的元素被设置为该元素类型的默认值
• 如果参数 array 为 null。抛出 ArgumentNullException 异常。
• 如果 参数 index 小于 0。抛出 IndexOutOfRangeException 异常。
• 如果 参数 length 小于0。抛出 IndexOutOfRangeException 异常
• 如果  index + length 大于 array 的大小。抛出 IndexOutOfRangeException 异常
• 此方法为 O (n) 操作，其中n是length。
• 此方法将数组中的每个元素重置为元素类型的默认值。 它将引用类型（包括String 对象）的元素设置为null，并将值类型的元素设置为下表中显示的默认值。 
• 注意： 此方法仅清除元素的值;  它不会删除元素本身。 数组具有固定大小;  因此，不能添加或删除元素。

类型	值
Boolean	false
所有整型和浮点数值类型	0 （零）
DateTime	DateTime.MinValue
其他值类型	该类型字段的默认值

static void Main(string[] args)
        {
            int[] numbers1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            // 从 numbers1 数组中索引2的位置开始清空元素，一共向后清空5个元素，被清空的元素都在相应的位置都初始化为0
            Array.Clear(numbers1, 2, 5);
            foreach (var tt in numbers1)
            {
                Write(tt);
            }
            WriteLine();

            int[,] numbers2 = { { 11, 22, 33 }, { 44, 55, 66 }, { 77, 88, 99 } };
            Array.Clear(numbers2, 2, 5);
            foreach (var tt in numbers2)
            {
                Write(tt);
            }

            WriteLine();

            int[,,] numbers3 = {{{1, 2}, {3, 4}},
                             {{5, 6}, {7, 8}},
                             {{9, 10}, {11, 12}}};
            Array.Clear(numbers3, 2, 5);
          
            foreach (var tt in numbers3)
            {
                Write(tt);
            }
        }

Array.Clone 

public object Clone ();

Clone 方法为数组进行浅复制，也就是说，它只创建了数组本身的克隆。 对于类型数组和引用类型数组而言，有不同的结果。

此方法为 O (n) 操作，其中n是Length。

• 克隆值类型数组会得到两个独立的数组。
• 克隆引用类型数组会导致两个数组指向相同的对象。

Clone方法返回 object类型的引用，该引用必须强制转换为数组类型。

下列代码克隆一个值类型数组的示例，它产生了两个独立的数组：

namespace HelloWorld_Console
{
  
    class Program
    {
      
        static void Main(string[] args)
        {
           int [] intArr1 = { 1, 2, 3 };
            int[] intArr2 = (int[])intArr1.Clone();
            WriteLine("输出intArr2数组中的值：");
            foreach (var tt in intArr2)
            {
                WriteLine(tt);
            }
            for (int i=0;i

克隆引用类型数组会导致两个数组指向相同的对象:

namespace HelloWorld_Console
{
    class A
    {
        public int Value = 5;
    }
    class Program
    {
        static void Main(string[] args)
        {
            A[] AArray1 = new A[3] { new A(), new A(), new A() };
            WriteLine("先输出AArray1的值：");
            foreach(var tt in AArray1)
            {
                WriteLine(tt.Value);
            }
 
            A[] AArray2 = (A[])AArray1.Clone();
            WriteLine("再输出AArray2的值：");
            foreach (var tt in AArray1)
            {
                WriteLine(tt.Value);
            }
            WriteLine("再输出AArray2的改变后的值：");
            for (int i=0;i

 

Array.Copy

将一个 Array 中的部分元素复制到另一个Array，并根据需要执行类型转换和装箱。

该操作有很多重载形式，具体看官网。

Array.CopyTo

public void CopyTo (Array array, int index);
[System.Runtime.InteropServices.ComVisible(false)]
public void CopyTo (Array array, long index);

• 从 array 数组中索引 index 开始处把当前数组对象的所有元素拷贝到 array 中。
• 注意： index 的索引值不能大于   “ 目标数组 array 中元素个数 减去当前数组的元素个数 ” ， index 也不能是 负数。
• 如果 参数 array 为 null。 抛出 ArgumentNullException
• 如果 参数 index 小于 0。抛出 ArgumentOutOfRangeException
• 如果参数 array 是多维数组。或 源数组中的元素数大于从 index 到目标 array 的末尾之间的可用元素数。抛出 ArgumentException
• 如果无法自动将源 Array 的元素类型转换为目标 array 的元素类型。抛出 ArrayTypeMismatchException
• 如果 源数组是多维数组。抛出  RankException
• 如果 源 Array 中至少有一个元素无法转换为目标 array 的类型。抛出 InvalidCastException
• 如果此方法在拷贝时抛出异常，则参数 array 的状态未定义。
• 此方法是O（n）操作，其中n是Length。它仅执行浅拷贝。

       static void Main(string[] args)
        {          
            Array mySourceArray = Array.CreateInstance(typeof(String), 3);
            mySourceArray.SetValue("three", 0);
            mySourceArray.SetValue("napping", 1);
            mySourceArray.SetValue("cheng", 2);
            Array myTargetArray = Array.CreateInstance(typeof(String),9);
            myTargetArray.SetValue("The", 0);
            myTargetArray.SetValue("quick", 1);
            myTargetArray.SetValue("foure", 2);
            myTargetArray.SetValue("five", 3);
            myTargetArray.SetValue("six", 4);
            myTargetArray.SetValue("seven", 5);
            myTargetArray.SetValue("eight", 6);
            mySourceArray.CopyTo(myTargetArray, 6);

            foreach(var tt in mySourceArray)
            {
                WriteLine(tt);
            }
            WriteLine();

            foreach (var tt in myTargetArray)
            {
                WriteLine(tt);
            }
         }

Array.CreateInstance

public static Array CreateInstance (Type elementType, int length);

• 创建一个 为 elementType 类型的， length 长度的数组新实例。
• 如果参数 elementType 为 null。抛出 ArgumentNullException
• 如果 参数 elementType 不是有效的 Type。抛出 ArgumentException
• 如果 参数 elementType 的类型为 void ，或 elementType 为泛型类型。抛出 NotSupportedException
• 如果参数 length 小于零。抛出 ArgumentOutOfRangeException
• 如果当前对象的实际元素数小于length，那么多余的元素将—— 如果是引用类型元素初始化为null。是 值类型元素初始化为零。
• 此方法为 O (n) 操作，其中n是length。

        static void Main(string[] args)
        {     
            // 该mySourceArray 对象中有三个元素，其余 6个初始化为空串
            Array mySourceArray = Array.CreateInstance(typeof(String), 9); 
            mySourceArray.SetValue("three", 0);
            mySourceArray.SetValue("napping", 1);
            mySourceArray.SetValue("cheng", 2);                   
        }

---

public static Array CreateInstance (Type elementType, params int[] lengths);
public static Array CreateInstance (Type elementType, params long[] lengths);

 如果参数 elementType 为 null。抛出 ArgumentNullException

如果参数 elementType 不是有效的 Type。或 lengths 数组包含的元素少于一个。抛出 ArgumentException

如果 参数 elementType 的类型为 void ，或 elementType 为泛型类型。抛出 NotSupportedException

如果参数 lengths 中的任何值都小于零。抛出 ArgumentOutOfRangeException

Array my4DArray = Array.CreateInstance(typeof(int), new int[4] {2, 3, 4, 5 });

---

public static Array CreateInstance (Type elementType, int length1, int length2);

• 创建一个 elementType 类型的， 第一维是 length1， 第二维是 length2 的二维数组新实例。
• 如果参数 elementType 为 null。抛出 ArgumentNullException
• 如果 参数 elementType 不是有效的 Type。抛出 ArgumentException
• 如果 参数 elementType 的类型为 void ，或 elementType 为泛型类型。抛出 NotSupportedException
• 如果参数 length 小于零。抛出 ArgumentOutOfRangeException

• 如果参数 length1 小于零。或 length2 小于零。都将抛出 ArgumentOutOfRangeException

        static void Main(string[] args)
        {               
            Array my4DArray = Array.CreateInstance(typeof(int), 2,2);
            my4DArray.SetValue("three", 0,0);
            my4DArray.SetValue("napping",0,1);
            my4DArray.SetValue("cheng",1,0);
            my4DArray.SetValue("huang", 1, 1);    
        }

Array.Exists

public static bool Exists (T[] array, Predicate match);

• 参数T: 为 数组元素的类型。
• 参数 array：要搜索的一维 Array。
• match：是一个 Predicate 谓词，定义要搜索元素的条件。
• 返回Boolean，如果 array 包含一个或多个与指定谓词所定义的条件相匹配的元素，则为 true；否则为 false。
• 如果参数 array 为 null。或 match 为 null。 抛出 ArgumentNullException

Array.Find

public static T Find (T[] array, Predicate match);

• 搜索与指定谓词所定义的条件相匹配的元素，并返回整个 Array 中的第一个匹配元素。

Array.GetLength

public int GetLength (int dimension);

• 返回一个整数，表示 Array  中 dimension 的维度中，有多少元素。
• 如果参数 dimension 小于零。 或 dimension 等于或大于 Rank。 抛出 IndexOutOfRangeException
• GetLength 的一个示例是GetLength（0），它返回 Array 的第一个维度中的元素数。
• 此方法为 o （1） 运算。

        static void Main(string[] args)
        {
            // 该mySourceArray 对象中有三个元素，其余 6个初始化为空串
            Array mySourceArray = Array.CreateInstance(typeof(String), 9);
            mySourceArray.SetValue("three", 0);
            mySourceArray.SetValue("napping", 1);
            mySourceArray.SetValue("cheng", 2);
            WriteLine(mySourceArray.GetLength(0));
        }

Array.GetValue

该操作有很多重载形式

public object GetValue (int index);
[System.Runtime.InteropServices.ComVisible(false)]
public object GetValue (long index);

• 返回一维数组 index 位置的值。
• 如果当前 Array 是多维数组。 抛出 ArgumentException
• 如果参数 index 大于等于 当前数组的个数 。抛出 IndexOutOfRangeException
• GetLowerBound 并 GetUpperBound 方法可以确定 index 是否超出范围。

        static void Main(string[] args)
        {          
            Array mySourceArray = Array.CreateInstance(typeof(String), 9);
            mySourceArray.SetValue("three", 0);
            mySourceArray.SetValue("napping", 1);
            mySourceArray.SetValue("cheng", 2);         
            WriteLine(mySourceArray.GetValue(2)); 
        }

---

public object GetValue (params int[] indices);

• 返回多维数组中 indies 下标位置的值
• 参数 indices 不能大于等于多维数组中任何一维中的元素数。
• 如果参数 indices 为 null。 抛出 ArgumentNullException
• 当前 Array 中的维数不等于 indices 中的元素数。抛出 ArgumentException
• 如果 参数 indices 中的任何元素都超出了当前 Array 的相应维度的有效索引范围。抛出 IndexOutOfRangeException
• 此方法为 o （1） 运算。

      static void Main(string[] args)
        {  
            String[] myArr1 = new String[5];          
          
           myArr1.SetValue("three", 3);
            Console.WriteLine("[3]:   {0}", myArr1.GetValue(3));
       
            String[,] myArr2 = new String[2, 2];

          
            myArr2.SetValue("one-three", 1,1);
            Console.WriteLine("[1,3]:   {0}", myArr2.GetValue(2, 1));
          
            String[,,] myArr3 = new String[5, 5, 5];
        
            myArr3.SetValue("one-two-three", 1, 2, 3);
            Console.WriteLine("[1,2,3]:   {0}", myArr3.GetValue(1, 2, 3));         
        }

Array.IndexOf

该方法有很多重载形式 

public static int IndexOf (Array array, object value);

• 在一个名为 array 数组中查找 value 值是否在 array 中，如果存在， 返回 value 在 array 对象中第一个匹配项的索引。若没找到，返回 -1。
• 如果参数 array 为 null。 抛出 ArgumentNullException
• 如果参数array 是多维的。抛出 RankException
• 此方法为 O (n) 操作，其中n是Length的array。

        static void Main(string[] args)
        {         
            String[] strings = { "quick", "brown", "fox", "jumps","over", "the", "lazy", "dog", "in", "the","barn" };               
            String searchString = "the";
            int index = Array.IndexOf(strings, searchString);
            Console.WriteLine("The first occurrence of \"{0}\" is at index {1}.", searchString, index); //返回 5         
        }

---

public static int IndexOf (Array array, object value, int startIndex);

• 从当前数组中 startIndex 索引处到数组的末尾中搜索 value ， 如果找到返回 value 在当前数组中的下标，否则返回-1，表示没有找到。
• 如果参数 array 为 null。抛出 ArgumentNullException
• 如果参数 startIndex  大于 array 的元素个数 或者小于0 。抛出 ArgumentOutOfRangeException
• 如果参数 array 是多维的。抛出 RankException
• 此方法是O（n）操作，其中 n 是从startIndex到数组末尾的元素数。

        static void Main(string[] args)
        {         
            String[] strings = { "quick", "brown", "fox", "lazy", "the", "in", "barn" };               
            String searchString = "the";
           int index = Array.IndexOf(strings, searchString, 7); 
            Console.WriteLine($"{searchString},{index}"); // 返回 -1
        }

---

public static int IndexOf (T[] array, T value);

•  在一个类型为T，名为 array 数组中搜索 value ，若找到，返回第一个匹配 value 的下标。否则，返回 -1
• 如果参数 array 为 null。抛出 ArgumentNullException
• 此方法为 O (n) 操作，其中n是Length的array。

  string[] dinosaurs = { "Tyrannosaurus", "Amarga", "Mamenchi", "Amarga", "Deino", "Tyranno", "Compsog" };
            Console.WriteLine(Array.IndexOf(dinosaurs, "Amarga"));

Array.GetLowerBound

public int GetLowerBound (int dimension);

• 获取当前数组中某个维度中第一个元素的索引值（一般都是0） 
• 如果参数 dimension 小于零。或 dimension 等于或大于 Rank。 抛出 IndexOutOfRangeException
• 如果当前数组对象为 null，抛出 NullReferenceException
• GetLowerBound(0) 返回数组的第一维的起始索引，GetLowerBound(Rank - 1)返回最后维度的数组的起始索引。
• GetLowerBound方法始终返回一个值，该值指示数组下限的索引，即使该数组为空。
• 此方法为 o （1） 运算。

        static void Main(string[] args)
        {
            int[,] integers2d = { {2, 4}, {3, 9}, {4, 16}, {5, 25},{6, 36}, {7, 49}, {8, 64}, {9, 81} };
            WriteLine(integers2d.GetLowerBound(0)); // 返回 0            
        }

请注意，尽管.NET Framework中的大多数数组都是从零开始的（即，GetLowerBound方法对于数组的每个维度都返回零），但.NET Framework确实支持非基于零的数组。 可以使用 CreateInstance(Type, Int32[], Int32[]) 方法创建此类数组，也可以从非托管代码返回。

Array.GetUpperBound

• 获取当前数组中某个维度中最后一个元素的索引值
• 如果参数 dimension 小于零。或 dimension 等于或大于 Rank。 抛出 IndexOutOfRangeException
• GetUpperBound（0）返回数组第一维中的最后一个索引，GetUpperBound（Rank  -  1）返回数组最后一维的最后一个索引。
• 此方法为 o （1） 运算。

      static void Main(string[] args)
        {          
            int[] integers = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };         
            int upper = integers.GetUpperBound(0);
            int lower = integers.GetLowerBound(0);
            Console.WriteLine($"Elements from index {lower} to {upper}:");
          
            for (int ctr = lower; ctr <= upper; ctr++)
            {
                Console.Write($"{integers[ctr]},");
            }

            Console.WriteLine();

         int[,] integers2d = { {2, 4}, {3, 9}, {4, 16}, {5, 25},
                            {6, 36}, {7, 49}, {8, 64}, {9, 81} };

             int rank = integers2d.Rank; // 获取该数组是几维数组
             Console.WriteLine($"Number of dimensions: {rank}");
             for (int ctr = 0; ctr < rank; ctr++)
                 Console.WriteLine($"   Dimension {ctr}: " +
                     $"from {integers2d.GetLowerBound(ctr)} to {integers2d.GetUpperBound(ctr)}");
        }

Array.LastIndexOf

有很多重载形式 

public static int LastIndexOf (Array array, object value);
public static int LastIndexOf (T[] array, T value);

• 返回 一个名为 array数组 的尾部向前搜索第一个 与 value 匹配的元素索引，如没找到，返回 -1.
• 如果参数 array 为 null。 抛出 ArgumentNullException
• 如果参数 array 是多维的。抛出 RankException
• 此方法为 O (n) 操作，其中n是Length的array。

        static void Main(string[] args)
        {          
            int[] integers = { 2, 8, 6, 8, 10, 8 };
            WriteLine(Array.LastIndexOf(integers, 8)); // 返回下标5
            WriteLine(Array.LastIndexOf(integers, 18)); // 返回下标-1
        }

---

public static int LastIndexOf (Array array, object value, int startIndex);
public static int LastIndexOf (T[] array, T value, int startIndex);

•  从 名为 array 的数组的 索引 0 开始 到 startIndex 结束范围内，从后往前搜索 是否有跟 value  匹配的元素。 若有，返回 value  在 array  中下标位置， 否则 返回 -1.
• 如果参数 array 为 null。抛出 ArgumentNullException
• 如果 参数 startIndex 超出了 array 的有效索引范围。抛出 ArgumentOutOfRangeException
• 如果参数 array 是多维的。抛出 RankException
• 此方法为 O (n) 操作，其中n是从开头的元素数目array到startIndex。

        static void Main(string[] args)
        {          
            int[] integers = { 2, 5, 6, 8, 10, 8 };
            WriteLine(Array.LastIndexOf(integers, 8,3)); // 返回下标值3           
        }

Array.Resize

public static void Resize (ref T[] array, int newSize);

• 将当前 名为 array 的数组的元素个数重新设置为  newSize;
• 如果参数 newSize 小于零。抛出 ArgumentOutOfRangeException
• 此方法分配具有指定大小的新数组，将旧数组中的元素复制到新数组，然后用新数组替换旧数组。数组必须是一维数组。
• 如果 newSize 大于旧数组的 Length，则分配一个新数组，然后将所有元素从旧数组复制到新数组。
• 如果 newSize 小于旧数组的 Length，则会分配一个新数组，并将元素从旧数组复制到新数组，在新数组中只会拷贝旧数组的前 newSize 个元素。旧数组中的多余元素将被忽略。
• 如果newSize等于旧数组的 Length，则此方法不执行任何操作。
• Resize方法仅调整一维数组的大小。 Array 类不包括用于调整多维数组大小的方法。
• 此方法是O（n）操作，其中 n 是newSize。
   

      public static void PrintIndexAndValues(String[] myArr)
        {
            for (int i = 0; i < myArr.Length; i++)
            {
                Console.WriteLine("   [{0}] : {1}", i, myArr[i]);
            }
            Console.WriteLine();
        }
        static void Main(string[] args)
        {
           
            String[] myArr = {"The", "quick", "brown"};                 
            PrintIndexAndValues(myArr);
        
            Array.Resize(ref myArr, myArr.Length + 5);         
            PrintIndexAndValues(myArr);

            Array.Resize(ref myArr, 4);         
            PrintIndexAndValues(myArr);
        }    


   [0] : The
   [1] : quick
   [2] : brown

   [0] : The
   [1] : quick
   [2] : brown
   [3] :
   [4] :
   [5] :
   [6] :
   [7] :

   [0] : The
   [1] : quick
   [2] : brown
   [3] : 

Array.Reverse

public static void Reverse (Array array);

• 对当前 array 中的元素反转。
• 如果参数 array 为 null。ArgumentNullException
• 如果 参数 array 是多维的。RankException

        static void Main(string[] args)
        {          
            String[] myArr = {"The", "quick", "brown"};
            Array.Reverse(myArr);
           foreach(var tt in myArr)
            {
                WriteLine(tt);
            }
        }  

---

public static void Reverse (Array array, int index, int length);

•  把一个名为 array 数组中的 index 开始处，然后反转length 个元素数。
• 注意： index + length 不能大于该 array 的元素个数
• 如果 参数 index 小于 array 的下限。或 length 小于零。抛出 ArgumentOutOfRangeException
• 如果参数 index 和 length 未在 array 中指定有效范围。抛出 ArgumentException

        static void Main(string[] args)
        {
            int[] myArr = { 55, 66, 77, 88, 99, 100, 111 };
            Array.Reverse(myArr,3,4);
           foreach(var tt in myArr)
            {
                Write($"{tt},"); // 输出 55,66,77,111,100,99,88,
            }
        }   

Array.SetValue

有很多重载形式 

public void SetValue (object value, int index);
[System.Runtime.InteropServices.ComVisible(false)]
public void SetValue (object value, long index);

• 把一维数组中 index 处，其设置为 value .
• 如果 当前 Array 是多维数组。抛出 ArgumentException
• 如果参数 value 不能转换为当前 Array 的元素类型。抛出 InvalidCastException
• 如果参数 index 大于等于 array 的元素个数。抛出 IndexOutOfRangeException
• 如果SetValue用于将null赋给值类型数组的元素，则该元素将被初始化为0。此时该元素的值不是空引用，并且不能通过搜索空引用找到。
• GetLowerBound 并 GetUpperBound方法可以确定索引的值是否超出范围。
• 该方法是O（1）操作。

        static void Main(string[] args)
        {
            int[] myArr = { 55, 66, 77, 88, 99, 100, 111 };
            myArr.SetValue(10000, 3);
            foreach (var tt in myArr)
            {
                Write($"{tt},"); // 55,66,77,10000,99,100,111,
            }
        } 

---

public void SetValue (object value, params int[] indices);
[System.Runtime.InteropServices.ComVisible(false)]
public void SetValue (object value, params long[] indices);

•  将当前的多维数组中的 indices 索引位置的值设置 为 value
• 注意： 参数 indices 中的数字不能等于大于 对应的维数值。
• 如果参数 indices 为 null。抛出 ArgumentNullException
• 当前 Array 中的维数不等于 indices 中指定维数的个数。抛出 ArgumentException
• 如果参数 value 不能转换为当前 Array 的元素类型。抛出 InvalidCastException
• 如果参数 indices 中的任何元素都超出了当前 Array 的相应维度的有效索引范围。抛出 IndexOutOfRangeException
• GetLowerBound 和 GetUpperBound方法可以确定indices数组中的任何值是否超出范围。
• 该方法是O（1）操作。

        static void Main(string[] args)
        {
            int[,] myArr2 = new int[4, 2] { { 55, 66 }, { 66, 77 }, { 77, 88 }, { 100, 110 } };
            myArr2.SetValue(10000, 1, 1);
            Console.WriteLine("[1,1]:   {0}", myArr2.GetValue(1, 1));
            foreach(var tt in  myArr2)
            {
                WriteLine(tt);
            }
        }

Array.Sort

该操作有很多重载形式

public static void Sort (Array array);

• 对一维数组中的所有元素进行排序
• 如果排序未成功完成，则结果不确定。
• 如果参数 array 为 null。抛出 ArgumentNullException
• 如果 array 是多维的。抛出 RankException
• 如果参数 array 中的一个或多个元素未实现 IComparable 接口。抛出 InvalidOperationException
• 此实现执行不稳定的排序; 也就是说，如果两个元素相等，则可能不会保留它们的顺序。 相反，稳定的排序保留了相等元素的顺序。

        static void Main(string[] args)
        {
            int[] myArr2 = new int[] {  66 , 77 ,88 , 110 ,55,63,411 };
            Array.Sort(myArr2);
            foreach(var tt in myArr2)
            {
                Write($"{tt},");
            }
        }

---

public static void Sort (Array array, int index, int length);

• 从名为 array 的一维数组中 index 索引处开始，这 length 元素 从小到大排序。
• 注意： index + length 不能大于 array 的元素个数。
• 如果排序未成功完成，则结果未定义。
• 此实现执行不稳定的排序; 也就是说，如果两个元素相等，则可能不会保留它们的顺序。 相反，稳定的排序保留了相等元素的顺序。
• 如果参数 array 为 null。抛出 ArgumentNullException
• 如果参数 array 是多维的。抛出 RankException
• 如果参数index 小于 array 的下限。或 length 小于零。抛出 ArgumentOutOfRangeException
• 如果参数 index 和 length 未在 array 中指定有效范围。抛出 ArgumentException
• 如果 参数 array 中的一个或多个元素未实现 IComparable 接口。抛出 InvalidOperationException

        static void Main(string[] args)
        {
            int[] myArr2 = new int[] {  66 , 77 ,88 , 110 ,55,63,411 };
            Array.Sort(myArr2, 3,4);
            foreach(var tt in myArr2)
            {
                Write($"{tt},");
            }
        }

---

End..