数组本身相对来说比较简单，C# 提供了很多数组方法，比如 Clear()、Reverse()、Sort() 等，这些方法都可以在需要使用的时候通过智能提示了解它的用法，本文不讲这些具体的方法。但还是有一些数组相关的知识点值得总结和知晓一下。
有的知识点，知不知道其实并不重要，工作中用的时候搜索一下就可以了，毕竟实现一个功能代码的写法有很多种，再牛的人也不可能完全熟悉一门语言的每个细节。当然了，多了解一点总是没有什么坏处，一些好用的 C# 特性或知识点兴许可以提高代码质量和编码效率。

数组的定义和初始化

定义和初始化一个数组有好几种方式，随着 C# 版本升级，方式也越来越简单：

  1. int[] arr = new int[3];           // 定义一个长度为 3 的数组
  2. int[] arr = new int[3] {1, 2, 3}; // 定义一个长度为 3 的数组并初始化
  3. int[] arr = new [] {1, 2, 3};     // 上面的简写
  4. int[] arr = {1, 2, 3};            // 上面的进一步简写

我们知道当定义一个固定长度的数组没有初始化时，比如：

  1. int[] arr = new int[3];

虽然没有初始化，但它是有默认值的，这个数组中包含了 3 个值为 0 的整数。如何使用非默认值创建一个数组呢？可以使用 System.Linq 命名空间下的 Enumerable.Repeat 方法：

  1. // 创建长度为 5 的整形数组，并用 100 来填充
  2. int[] arr = Enumerable.Repeat(100, 5).ToArray();
  4. // 创建长度为 5 的字符串数组，并用“C#”来填充
  5. string[] arr = Enumerable.Repeat("C#", 5).ToArray();

另外，数组的一个显著特点是，一个数组中所有元素的类型必须一致。

数组的复制、克隆与比较

把一个数组的元素复制到另一个数组，可以使用 Array.Copy() 方法，复制时源数组取值和目标数组赋值都是从索引 0 开始的：

  1. var sourceArray = new int[] { 11, 12, 3, 5, 2, 9};
  2. var destinationArray = new int[3];
  3. Array.Copy(sourceArray, destinationArray, 3);
  4. // destinationArray = [11, 12, 3]

克隆一个数组很简单：

  1. var sourceArray = new int[] { 11, 12, 3 };
  2. var destinationArray = (int[])sourceArray.Clone();
  3. // destinationArray = [11, 12, 3]

比较两个数组是否一样，即两个数组包含的元素及元素的顺序是否都一样，可以使用数组的 SequenceEqual 方法：

  1. int[] arr1 = { 3, 5, 7 };
  2. int[] arr2 = { 3, 5, 7 };
  3. bool result = arr1.SequenceEqual(arr2); // true

以上只是罗列几个有代表性的比较快捷简单的数组操作，在 C# 中借助 Linq 可以实现更复杂的数组操作，这里先不作总结。

使用指针遍历数组

实际的 C#开发中很少会直接用到指针，在需要进行底层操作时可能会用到。在 C# 中使用指针时需要在 unsafe 上下文中操作：

  1. int[] arr = new int[] {1, 6, 3, 3, 9};
  3. // 使用 foreach
  4. foreach (int element in arr)
  5. {
  6.     Console.WriteLine(element);
  7. }
  9. // 使用指针
  10. unsafe
  11. {
  12.     int length = arr.Length;
  13.     fixed (int* p = arr)
  14.     {
  15.         int* pInt = p;
  16.         while (length-- > 0)
  17.         {
  18.             Console.WriteLine(*pInt);
  19.             pInt++; // 将指针移到下一个元素
  20.         }
  21.     }
  22. }
  23. // 依次输出：1 6 3 3 9

这里只是让大家知道有这么一回事，指针不是本篇的话题，更多关于指针的操作可以访问：

生成有序数组

我就见过有人使用 for 循环生成一个从 n 到 m 的有序数组，其实 C# 提供了 Enumerable.Range 方法可以很容易地创建一个有序的整型数组。示例：

  1. // 创建数字从 1 到 100 的数组
  2. int[] sequence = Enumerable.Range(1, 100).ToArray();
  4. // 结合 Linq 还可以实现更复杂的数组创建逻辑
  5. int[] squares = Enumerable.Range(2, 10).Select(x => x * x).ToArray(); // 3, 9, 16...

多维数组和交错数组的区别

简单来说，多维数组每一行长度都是固定的，比如二维数组是一个 m 行 n 列的矩阵：

  1. int[,] arr = {
  2.    {1, 2, 3, 4},
  3.    {4, 2, 1, 3},
  4.    {2, 1, 3, 4},
  5. }

而交错数组（又叫锯齿数组）的每一行可以有不同的大小，表示的是数组的数组。比如：

  1. int[][] arr = {
  2.     new [] {1, 2, 3, 4},
  3.     new [] {1, 2},
  4.     new [] {1, 2, 3},
  5. }

它们的定义、初始化、取值、赋值等都有明显的区别。
先看多维数组：

  1. // 多维数组的定义
  2. int[,]  arr = new int[10, 10];     // 二维数组
  3. int[,,] arr = new int[10, 10, 10]; // 三维数组
  5. // 多维数组的初始化 (new int[3, 2] 可以省略)
  6. int[,] arr = new int[3, 2] { {1, 1}, {2, 2}, {3, 3} };
  8. // 多维数组的取值
  9. Console.WriteLine(arr[2, 1]); // 3
  11. // 多维数组的赋值
  12. arr[2, 1] = 10;

再对比交错数组：

  1. // 交错数组的定义
  2. int[][]   arr = new int[10][];   // 二层：数组的数组
  3. int[][][] arr = new int[10][][]; // 三层：数组的数组的数组
  5. // 交错数组的初始化 (new int[3][] 可以省略)
  6. int[][] arr = new int[3][] { new [] {1}, new [] {2, 2}, new [] {3, 3, 3} };
  8. // 交错数组的取值
  9. Console.WriteLine(arr[2][1]); // 3
  11. // 多维数组的赋值
  12. arr[2][1] = 10;

注意：多维数组每行长度必须一致；交错数组第二个 [] 是不能有数字的。两者的 Length 属性意义也是不一样的，多维数组的 Length 属性取的是数组所有元素的总数，而交错数组取的是第一层的数组的个数。例如：

  1. int[,] arr1 = new int[3, 2] { { 1, 1 }, { 2, 2 }, { 3, 3 } };
  2. Console.WriteLine(arr1.Length); // 输出：6
  4. int[][] arr2 = new int[3][] { new[] { 1 }, new[] { 2, 2 }, new[] { 3, 3, 3 } };
  5. Console.WriteLine(arr2.Length); // 输出：3

建议：除了某些像矩阵这样的操作场景可能更适合使用多维数组，大多数场景应尽量选择使用交错数组。功能上多维数组可以实现的，交错数组也都能实现，反过来不一定可以。另外，根据 stackoverflow 网友的回答（下面参考链接），在 .NET 中，交错数组性能上要好于多维数组。