正文

深入解析C#中的交错数组与隐式类型的数组

︶ㄣ米米素材网 メ
米米素材网V管理员 / 阅读
0708

这篇文章主要介绍了深入解析C#中的交错数组与隐式类型的数组,隐式类型的数组通常与匿名类型以及对象初始值设定项和集合初始值设定项一起使用,需要的朋友可以参考下

交错数组
交错数组是元素为数组的数组。交错数组元素的维度和大小可以不同。交错数组有时称为“数组的数组”。以下示例说明如何声明、初始化和访问交错数组。
下面声明一个由三个元素组成的一维数组，其中每个元素都是一个一维整数数组：

?
1
int[][] jaggedArray = new int[3][];

必须初始化 jaggedArray 的元素后才可以使用它。可以如下例所示初始化该元素：

?
1
2
3
jaggedArray[0] = new int[5];
jaggedArray[1] = new int[4];
jaggedArray[2] = new int[2];

每个元素都是一个一维整数数组。第一个元素是由 5 个整数组成的数组，第二个是由 4 个整数组成的数组，而第三个是由 2 个整数组成的数组。
也可以使用初始值设定项用值填充数组元素，在这种情况下不需要数组大小。例如：

?
1
2
3
jaggedArray[0] = new int[] { 1, 3, 5, 7, 9 };
jaggedArray[1] = new int[] { 0, 2, 4, 6 };
jaggedArray[2] = new int[] { 11, 22 };

还可以在声明数组时将其初始化，如：

?
1
2
3
4
5
6
  int[][] jaggedArray2 = new int[][]
{
  new int[] {1,3,5,7,9},
  new int[] {0,2,4,6},
  new int[] {11,22}
};

可以使用下面的速记格式。请注意：不能从元素初始化中省略 new 运算符，因为不存在元素的默认初始化：

?
1
2
3
4
5
6
  int[][] jaggedArray3 =
{
  new int[] {1,3,5,7,9},
  new int[] {0,2,4,6},
  new int[] {11,22}
};

交错数组是数组的数组，因此其元素是引用类型并初始化为 null。
可以如下例所示访问个别数组元素：

?
1
2
3
4
5
// Assign 77 to the second element ([1]) of the first array ([0]):
jaggedArray3[0][1] = 77;
 
// Assign 88 to the second element ([1]) of the third array ([2]):
jaggedArray3[2][1] = 88;

可以混合使用交错数组和多维数组。下面声明和初始化一个一维交错数组，该数组包含大小不同的三个二维数组元素。有关二维数组的详细信息，请参阅多维数组（C# 编程指南）。

?
1
2
3
4
5
6
int[][,] jaggedArray4 = new int[3][,]
{
  new int[,] { {1,3}, {5,7} },
  new int[,] { {0,2}, {4,6}, {8,10} },
  new int[,] { {11,22}, {99,88}, {0,9} }
};

可以如本例所示访问个别元素，该示例显示第一个数组的元素 [1,0] 的值（值为 5）：

System.Console.Write("{0}", jaggedArray4[0][1, 0]);
方法 Length 返回包含在交错数组中的数组的数目。例如，假定您已声明了前一个数组，则此行：

System.Console.WriteLine(jaggedArray4.Length);
返回值 3。
本例生成一个数组，该数组的元素为数组自身。每一个数组元素都有不同的大小。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class ArrayTest
{
  static void Main()
  {
    // Declare the array of two elements:
    int[][] arr = new int[2][];
 
    // Initialize the elements:
    arr[0] = new int[5] { 1, 3, 5, 7, 9 };
    arr[1] = new int[4] { 2, 4, 6, 8 };
 
    // Display the array elements:
    for (int i = 0; i < arr.Length; i++)
    {
      System.Console.Write("Element({0}): ", i);
 
      for (int j = 0; j < arr[i].Length; j++)
      {
        System.Console.Write("{0}{1}", arr[i][j], j == (arr[i].Length - 1) ? "" : " ");
      }
      System.Console.WriteLine();     
    }
    // Keep the console window open in debug mode.
    System.Console.WriteLine("Press any key to exit.");
    System.Console.ReadKey();
  }
}

输出：

?
1
2
Element(0): 1 3 5 7 9
Element(1): 2 4 6 8


隐式类型的数组
可以创建隐式类型的数组，在这样的数组中，数组实例的类型是从数组初始值设定项中指定的元素推断而来的。有关任何隐式类型变量的规则也适用于隐式类型的数组。
在查询表达式中，隐式类型的数组通常与匿名类型以及对象初始值设定项和集合初始值设定项一起使用。
下面的示例演示如何创建隐式类型的数组：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class ImplicitlyTypedArraySample
{
  static void Main()
  {
    var a = new[] { 1, 10, 100, 1000 }; // int[]
    var b = new[] { "hello", null, "world" }; // string[]
 
    // single-dimension jagged array
    var c = new[] 
{
  new[]{1,2,3,4},
  new[]{5,6,7,8}
};
 
    // jagged array of strings
    var d = new[] 
{
  new[]{"Luca", "Mads", "Luke", "Dinesh"},
  new[]{"Karen", "Suma", "Frances"}
};
  }
}

请注意，在上一个示例中，没有在初始化语句的左侧对隐式类型的数组使用方括号。另请注意，交错数组就像一维数组那样使用 new [] 进行初始化。
对象初始值设定项中的隐式类型的数组
创建包含数组的匿名类型时，必须在该类型的对象初始值设定项中对数组进行隐式类型化。在下面的示例中，contacts 是一个隐式类型的匿名类型数组，其中每个匿名类型都包含一个名为 PhoneNumbers 的数组。请注意，对象初始值设定项内部未使用 var 关键字。

?
1
2
3
4
5
6
7
8
9
10
11
    var contacts = new[]
{
  new {
      Name = " Eugene Zabokritski",
      PhoneNumbers = new[] { "206-555-0108", "425-555-0001" }
    },
  new {
      Name = " Hanying Feng",
      PhoneNumbers = new[] { "650-555-0199" }
    }
};