Arrays
An array is a data structure that contains several variables of the same type. Arrays are declared with a type:
type[] arrayName;
The following examples create single-dimensional, multidimensional, and jagged arrays:
class TestArraysClass
{
static void Main()
{
// Declare a single-dimensional array
int[] array1 = new int[5];
// Declare and set array element values
int[] array2 = new int[] { 1, 3, 5, 7, 9 };
// Alternative syntax
int[] array3 = { 1, 2, 3, 4, 5, 6 };
// Declare a two dimensional array
int[,] multiDimensionalArray1 = new int[2, 3];
// Declare and set array element values
int[,] multiDimensionalArray2 = { { 1, 2, 3 }, { 4, 5, 6 } };
// Declare a jagged array
int[][] jaggedArray = new int[6][];
// Set the values of the first array in the jagged array structure
jaggedArray[0] = new int[4] { 1, 2, 3, 4 };
}
}
|
Array Overview
An array has the following properties:
An array can be Single-Dimensional, Multidimensional or Jagged.
The default value of numeric array elements are set to zero, and reference elements are set to null.
A jagged array is an array of arrays, and therefore its elements are reference types and are initialized to null.
Arrays are zero indexed: an array with n elements is indexed from 0 to n-1.
Array elements can be of any type, including an array type.
Array types are reference types derived from the abstract base type Array. Since this type implements IEnumerable and IEnumerable<(Of <(T>)>), you can use foreach iteration on all arrays in C#.
Массивы
Массив — это структура данных, содержащая несколько переменных одного типа. Массивы объявляются со следующим типом.
type[] arrayName;
В следующем примере показано создание одномерных, многомерных массивов и массивов, элементами которых являются массивы.
--
Общие сведения о массивах
Массив имеет следующие свойства.
Массив может быть одномерным, многомерным или массивом массивов.
Значение по умолчанию числовых элементов массива задано равным нулю, а элементы ссылок имеют значение NULL.
Невыровненный массив является массивом массивов и поэтому его элементы являются ссылочными типами и инициализируются значением null.
Индексация массивов начинается с нуля: массив с n элементами индексируется от 0 до n-1.
Элементы массива могут быть любых типов, включая тип массива.
Типы массива являются ссылочными типами, производными от абстрактного базового типа Array. Поскольку этот тип реализует IEnumerable и IEnumerable<(Of <(T>)>), в C# во всех массивах можно использовать итерацию foreach.
Arrays as Objects
In C#, arrays are actually objects, and not just addressable regions of contiguous memory as in C and C++. Array is the abstract base type of all array types. You can use the properties, and other class members, that Array has. An example of this would be using the Length property to get the length of an array. The following code assigns the length of the numbers array, which is 5, to a variable called lengthOfNumbers:
int[] numbers = { 1, 2, 3, 4, 5 };
int lengthOfNumbers = numbers.Length;
|
The System.Array class provides many other useful methods and properties for sorting, searching, and copying arrays.
Example
This example uses the Rank property to display the number of dimensions of an array.
class TestArraysClass
{
static void Main()
{
// Declare and initialize an array:
int[,] theArray = new int[5, 10];
System.Console.WriteLine("The array has {0} dimensions.", theArray.Rank);
}
}
|
Output
The array has 2 dimensions.
Массивы как объекты
В языке C# массивы являются объектами, а не просто смежными адресуемыми областями памяти, как в C и C++. Array является абстрактным базовым типом для всех типов массивов. Можно использовать свойства и другие члены класса, которые имеет Array. В примере используется свойство Length для получения длины массива. В следующем коде длина массива numbers, равная 5, присваивается переменной lengthOfNumbers:
int[] numbers = { 1, 2, 3, 4, 5 };
int lengthOfNumbers = numbers.Length;
|
Класс System.Array позволяет использовать много других полезных методов и свойств для выполнения сортировки, поиска и копирования массивов.
Пример
В этом примере свойство Rank используется для отображения числа измерений массива.
class TestArraysClass
{
static void Main()
{
// Declare and initialize an array:
int[,] theArray = new int[5, 10];
System.Console.WriteLine("The array has {0} dimensions.", theArray.Rank);
}
}
|
Результат
The array has 2 dimensions.
Single-Dimensional Arrays
You can declare an array of five integers as in the following example:
int[] array = new int[5];
|
This array contains the elements from array[0] to array[4]. The new operator is used to create the array and initialize the array elements to their default values. In this example, all the array elements are initialized to zero.
An array that stores string elements can be declared in the same way. For example:
string[] stringArray = new string[6];
|
Array Initialization
It is possible to initialize an array upon declaration, in which case, the rank specifier is not needed because it is already supplied by the number of elements in the initialization list. For example:
int[] array1 = new int[] { 1, 3, 5, 7, 9 };
|
A string array can be initialized in the same way. The following is a declaration of a string array where each array element is initialized by a name of a day:
string[] weekDays = new string[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
|
When you initialize an array upon declaration, you can use the following shortcuts:
int[] array2 = { 1, 3, 5, 7, 9 };
string[] weekDays2 = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
|
It is possible to declare an array variable without initialization, but you must use the new operator when you assign an array to this variable. For example:
int[] array3;
array3 = new int[] { 1, 3, 5, 7, 9 }; // OK
//array3 = {1, 3, 5, 7, 9}; // Error
|
C# 3.0 introduces implicitly typed arrays.
Value Type and Reference Type Arrays
Consider the following array declaration:
SomeType[] array4 = new SomeType[10];
|
The result of this statement depends on whether SomeType is a value type or a reference type. If it is a value type, the statement creates an array of 10 instances of the type SomeType. If SomeType is a reference type, the statement creates an array of 10 elements, each of which is initialized to a null reference.
Одномерные массив
Можно объявить массив из пяти целых чисел, как показано в следующем примере:
--
Массив содержит элементы с array[0] по array[4]. Оператор new служит для создания массива и инициализации элементов массива со значениями по умолчанию. В данном примере элементы массива инициализируются значением 0.
Массив, в котором хранятся строковые элементы, можно объявить таким же образом. Пример.
--
Инициализация массива
Массив можно инициализировать при объявлении. В этом случае спецификация ранга не нужна, поскольку она уже предоставлена по числу элементов в списке инициализации. Пример.
int[] array1 = new int[] { 1, 3, 5, 7, 9 };
|
Строковый массив можно инициализировать таким же образом. Ниже приведено объявление строкового массива, в котором каждый элемент инициализируется названием дня:
string[] weekDays = new string[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
|
При инициализации массива при объявлении можно использовать следующие сочетания клавиш:
int[] array2 = { 1, 3, 5, 7, 9 };
string[] weekDays2 = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
|
Можно объявить переменную массива без инициализации, но при присвоении массива этой переменной нужно использовать оператор new. Пример.
int[] array3;
array3 = new int[] { 1, 3, 5, 7, 9 }; // OK
//array3 = {1, 3, 5, 7, 9}; // Error
|
В C# 3.0 поддерживаются неявно типизированные массивы.
Массивы типов значений и ссылочных типов.
Рассмотрим следующие объявления массива:
SomeType[] array4 = new SomeType[10];
|
Результат этого оператора зависит от того, является ли SomeType типом значения или ссылочным типом. Если это тип значения, оператор создает массив из 10 экземпляров типа SomeType. Если SomeType — ссылочный тип, оператор создает массив из 10 элементов, каждый из которых инициализируется нулевой ссылкой null.
Multidimensional Arrays
Arrays can have more than one dimension. For example, the following declaration creates a two-dimensional array of four rows and two columns:
int[,] array = new int[4, 2];
|
Also, the following declaration creates an array of three dimensions, 4, 2, and 3:
int[, ,] array1 = new int[4, 2, 3];
|
Array Initialization
You can initialize the array upon declaration as shown in the following example:
int[,] array2D = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
int[, ,] array3D = new int[,,] { { { 1, 2, 3 } }, { { 4, 5, 6 } } };
|
You can also initialize the array without specifying the rank:
int[,] array4 = { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
|
If you choose to declare an array variable without initialization, you must use the new operator to assign an array to the variable. For example:
int[,] array5;
array5 = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } }; // OK
//array5 = {{1,2}, {3,4}, {5,6}, {7,8}}; // Error
|
You can also assign a value to an array element, for example:
The following code example initializes the array variables to default (except for jagged arrays):
int[,] array6 = new int[10, 10];
|
Многомерные массивы
Массивы могут иметь несколько измерений. Например, следующее объявление создает двумерный массив из четырех строк и двух столбцов.
int[,] array = new int[4, 2];
|
А следующее объявление создает трехмерный массив с количеством элементов 4, 2 и 3:
int[, ,] array1 = new int[4, 2, 3];
|
Инициализация массива
Массив можно инициализировать при объявлении, как показано в следующем примере:
int[,] array2D = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
int[, ,] array3D = new int[,,] { { { 1, 2, 3 } }, { { 4, 5, 6 } } };
|
Можно также инициализировать массив, не указывая его размерность:
int[,] array4 = { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
|
Если нужно создать переменную массива без инициализации, то необходимо использовать оператор new, чтобы присвоить массив переменной. Например:
int[,] array5;
array5 = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } }; // OK
//array5 = {{1,2}, {3,4}, {5,6}, {7,8}}; // Error
|
Можно также присвоить значение элементу массива, например:
В следующем примере кода элементы массива инициализируются значениями по умолчанию
int[,] array6 = new int[10, 10];
|
Jagged Arrays
A jagged array is an array whose elements are arrays. The elements of a jagged array can be of different dimensions and sizes. A jagged array is sometimes called an "array of arrays." The following examples show how to declare, initialize, and access jagged arrays.
The following is a declaration of a single-dimensional array that has three elements, each of which is a single-dimensional array of integers:
int[][] jaggedArray = new int[3][];
|
Before you can use jaggedArray, its elements must be initialized. You can initialize the elements like this:
jaggedArray[0] = new int[5];
jaggedArray[1] = new int[4];
jaggedArray[2] = new int[2];
|
Each of the elements is a single-dimensional array of integers. The first element is an array of 5 integers, the second is an array of 4 integers, and the third is an array of 2 integers.
It is also possible to use initializers to fill the array elements with values, in which case you do not need the array size. For example:
jaggedArray[0] = new int[] { 1, 3, 5, 7, 9 };
jaggedArray[1] = new int[] { 0, 2, 4, 6 };
jaggedArray[2] = new int[] { 11, 22 };
|
You can also initialize the array upon declaration like this:
int[][] jaggedArray2 = new int[][]
{
new int[] {1,3,5,7,9},
new int[] {0,2,4,6},
new int[] {11,22}
};
|
You can use the following shorthand form. Notice that you cannot omit the new operator from the elements initialization because there is no default initialization for the elements:
int[][] jaggedArray3 =
{
new int[] {1,3,5,7,9},
new int[] {0,2,4,6},
new int[] {11,22}
};
|
A jagged array is an array of arrays, and therefore its elements are reference types and are initialized to null.
Массивы массивов
Массив массивов — это массив, элементы которого сами являются массивами. Элементы массива массивов могут иметь различные размеры и измерения. Массивы массивов иногда также называются "невыровненными массивами". В следующих примерах показано, как выполняется объявление, инициализация и доступ к массивам массивов.
Ниже показано объявление одномерного массива, включающего три элемента, каждый из которых является одномерным массивом целых чисел.
int[][] jaggedArray = new int[3][];
|
Перед использованием jaggedArray его элементы нужно инициализировать. Сделать это можно следующим образом.
jaggedArray[0] = new int[5];
jaggedArray[1] = new int[4];
jaggedArray[2] = new int[2];
|
Каждый элемент представляет собой одномерный массив целых чисел. Первый элемент массива состоит из пяти целых чисел, второй — из четырех и третий — из двух.
Для заполнения элементов массива значениями можно также использовать инициализаторы, при этом размер массива знать не требуется. Пример.
jaggedArray[0] = new int[] { 1, 3, 5, 7, 9 };
jaggedArray[1] = new int[] { 0, 2, 4, 6 };
jaggedArray[2] = new int[] { 11, 22 };
|
Также массив можно инициализировать путем объявления.
int[][] jaggedArray2 = new int[][]
{
new int[] {1,3,5,7,9},
new int[] {0,2,4,6},
new int[] {11,22}
};
|
Также можно использовать сокращенную форму. Обратите внимание, что при инициализации элементов оператор new опускать нельзя, так как инициализации по умолчанию для этих элементов не существует.
--
Невыровненный массив является массивом массивов, и поэтому его элементы являются ссылочными типами и инициализируются значением null.
You can access individual array elements like these examples:
// 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;
|
It is possible to mix jagged and multidimensional arrays. The following is a declaration and initialization of a single-dimensional jagged array that contains two-dimensional array elements of different sizes:
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} }
};
|
You can access individual elements as shown in this example, which displays the value of the element [1,0] of the first array (value 5):
System.Console.Write("{0}", jaggedArray4[0][1, 0]);
|
The method Length returns the number of arrays contained in the jagged array. For example, assuming you have declared the previous array, this line:
System.Console.WriteLine(jaggedArray4.Length);
|
will return a value of 3.
Доступ к отдельным элементам массива выполняется следующим образом.
// 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;
|
Массивы массивов можно смешивать с многомерными массивами. Ниже показано объявление и инициализация одномерного массива массивов, состоящего из двумерных элементов различного размера.
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.
Example
This example builds an array whose elements are themselves arrays. Each one of the array elements has a different size.
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();
}
}
}
|
Output
Element(0): 1 3 5 7 9
Element(1): 2 4 6 8
Пример
В этом примере выполняется создание массива, элементы которого сами являются массивами. Каждый элемент массива имеет собственный размер.
--
Результат
Element(0): 1 3 5 7 9
Element(1): 2 4 6 8
Using foreach with Arrays
C# also provides the foreach statement. This statement provides a simple, clean way to iterate through the elements of an array. For example, the following code creates an array called numbers and iterates through it with the foreach statement:
int[] numbers = { 4, 5, 6, 1, 2, 3, -2, -1, 0 };
foreach (int i in numbers)
{
System.Console.WriteLine(i);
}
|
With multidimensional arrays, you can use the same method to iterate through the elements, for example:
int[,] numbers2D = new int[3, 2] { { 9, 99 }, { 3, 33 }, { 5, 55 } };
foreach (int i in numbers2D)
{
System.Console.Write("{0} ", i);
}
|
The output of this example is:
9 99 3 33 5 55
However, with multidimensional arrays, using a nested for loop gives you more control over the array elements.
Использование оператора foreach с массивами
В C# также предусмотрен оператор foreach. Этот оператор обеспечивает простой и понятный способ выполнения итерации элементов в массиве. Например, следующий код создает массив numbers и осуществляет его итерацию с помощью оператора foreach.
int[] numbers = { 4, 5, 6, 1, 2, 3, -2, -1, 0 };
foreach (int i in numbers)
{
System.Console.WriteLine(i);
}
|
Этот же метод можно использовать для итерации элементов в многомерных массивах, например:
int[,] numbers2D = new int[3, 2] { { 9, 99 }, { 3, 33 }, { 5, 55 } };
foreach (int i in numbers2D)
{
System.Console.Write("{0} ", i);
}
|
В результате выполнения примера получается следующий результат:
9 99 3 33 5 55
Однако для лучшего контроля элементов в многомерных массивах можно использовать вложенный цикл for.
Passing Arrays as Parameters
Arrays may be passed to methods as parameters. As arrays are reference types, the method can change the value of the elements.
Passing single-dimensional arrays as parameters
You can pass an initialized single-dimensional array to a method. For example:
The method called in the line above could be defined as:
void PrintArray(int[] arr)
{
// method code
}
|
You can also initialize and pass a new array in one step. For example:
PrintArray(new int[] { 1, 3, 5, 7, 9 });
|
Передача массивов в качестве параметров
Массивы можно передавать в методы в качестве параметров. Поскольку массивы являются ссылочными типами, метод может изменять значение элементов.
Передача одномерных массивов в качестве параметров
Инициализированный одномерный массив можно передать в метод. Пример.
Метод, вызываемый в приведенной выше строке, может быть задан как:
void PrintArray(int[] arr)
{
// method code
}
|
Новый массив можно инициализировать и передать за одно действие. Пример.
PrintArray(new int[] { 1, 3, 5, 7, 9 });
|
Example 1
Description
In the following example, a string array is initialized and passed as a parameter to the PrintArray method, where its elements are displayed:
Code
class ArrayClass
{
static void PrintArray(string[] arr)
{
for (int i = 0; i < arr.Length; i++)
{
System.Console.Write(arr[i] + "{0}", i < arr.Length - 1 ? " " : "");
}
System.Console.WriteLine();
}
static void Main()
{
// Declare and initialize an array:
string[] weekDays = new string[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
// Pass the array as a parameter:
PrintArray(weekDays);
}
}
|
Output 1
Sun Mon Tue Wed Thu Fri Sat
Пример 1
Описание
В следующем примере массив строк инициализируется и передается в качестве параметра в метод PrintArray, где отображаются его элементы:
Код
class ArrayClass
{
static void PrintArray(string[] arr)
{
for (int i = 0; i < arr.Length; i++)
{
System.Console.Write(arr[i] + "{0}", i < arr.Length - 1 ? " " : "");
}
System.Console.WriteLine();
}
static void Main()
{
// Declare and initialize an array:
string[] weekDays = new string[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
// Pass the array as a parameter:
PrintArray(weekDays);
}
}
|
Результат 1
Sun Mon Tue Wed Thu Fri Sat
Passing multidimensional arrays as parameters
You can pass an initialized multidimensional array to a method. For example, if theArray is a two dimensional array:
The method called in the line above could be defined as:
void PrintArray(int[,] arr)
{
// method code
}
|
You can also initialize and pass a new array in one step. For example:
PrintArray(new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } });
|
Передача многомерных массивов в качестве параметров
Инициализированный многомерный массив можно передать в метод. Например, если theArray является двумерным массивом:
Метод, вызываемый в приведенной выше строке, может быть задан как:
void PrintArray(int[,] arr)
{
// method code
}
|
Новый массив можно инициализировать и передать за одно действие. Пример.
PrintArray(new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } });
|
Example 2
Description
In this example, a two-dimensional array is initialized and passed to the PrintArray method, where its elements are displayed.
Code
class ArrayClass2D
{
static void PrintArray(int[,] arr)
{
// Display the array elements:
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 2; j++)
{
System.Console.WriteLine("Element({0},{1})={2}", i, j, arr[i, j]);
}
}
}
static void Main()
{
// Pass the array as a parameter:
PrintArray(new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } });
}
}
|
Output 2
Element(0,0)=1
Element(0,1)=2
Element(1,0)=3
Element(1,1)=4
Element(2,0)=5
Element(2,1)=6
Element(3,0)=7
Element(3,1)=8
Пример 2
Описание
В данном примере двумерный массив строк инициализируется и передается в метод PrintArray, где отображаются его элементы.
Код
--
Passing Arrays Using ref and out
Like all out parameters, an out parameter of an array type must be assigned before it is used; that is, it must be assigned by the callee. For example:
static void TestMethod1(out int[] arr)
{
arr = new int[10]; // definite assignment of arr
}
|
Like all ref parameters, a ref parameter of an array type must be definitely assigned by the caller. Therefore, there is no need to be definitely assigned by the callee. A ref parameter of an array type may be altered as a result of the call. For example, the array can be assigned the null value or can be initialized to a different array. For example:
static void TestMethod2(ref int[] arr)
{
arr = new int[10]; // arr initialized to a different array
}
|
The following two examples demonstrate the difference between out and ref when used in passing arrays to methods.
Передача массивов при помощи параметров ref и out
Как и все параметры out, параметр out типа массива должен принять какое-либо значение внутри вызываемого метода. Пример.
static void TestMethod1(out int[] arr)
{
arr = new int[10]; // definite assignment of arr
}
|
Как и все параметры ref, параметр ref типа массива должен быть определен перед вызовом метода. При этом внутри вызванного метода присвоение не требуется. В результате вызова метода параметр ref типа массива может оказаться измененным. Например, массиву можно присвоить значение null, или же его можно инициализировать в другой массив. Пример.
static void TestMethod2(ref int[] arr)
{
arr = new int[10]; // arr initialized to a different array
}
|
Следующие два примера демонстрируют отличия между параметрами out и ref при использовании с массивами.
Example 1
In this example, the array theArray is declared in the caller (the Main method), and initialized in the FillArray method. Then, the array elements are returned to the caller and displayed.
class TestOut
{
static void FillArray(out int[] arr)
{
// Initialize the array:
arr = new int[5] { 1, 2, 3, 4, 5 };
}
static void Main()
{
int[] theArray; // Initialization is not required
// Pass the array to the callee using out:
FillArray(out theArray);
// Display the array elements:
System.Console.WriteLine("Array elements are:");
for (int i = 0; i < theArray.Length; i++)
{
System.Console.Write(theArray[i] + " ");
}
}
}
|
Output 1
Array elements are:
1 2 3 4 5
Пример 1
В этом примере массив theArray объявлен в вызывающем методе (метод Main) и инициализирован внутри вызванного метода FillArray. Затем элементы инициализированного таким образом массива отображаются в вызывающем методе Main.
--
Example 2
In this example, the array theArray is initialized in the caller (the Main method), and passed to the FillArray method by using the ref parameter. Some of the array elements are updated in the FillArray method. Then, the array elements are returned to the caller and displayed.
class TestRef
{
static void FillArray(ref int[] arr)
{
// Create the array on demand:
if (arr == null)
{
arr = new int[10];
}
// Fill the array:
arr[0] = 1111;
arr[4] = 5555;
}
static void Main()
{
// Initialize the array:
int[] theArray = { 1, 2, 3, 4, 5 };
// Pass the array using ref:
FillArray(ref theArray);
// Display the updated array:
System.Console.WriteLine("Array elements are:");
for (int i = 0; i < theArray.Length; i++)
{
System.Console.Write(theArray[i] + " ");
}
}
}
|
Output 2
Array elements are:
1111 2 3 4 5555
Пример 2
В этом примере массив theArray инициализирован в вызывающем методе Main и подставляется в метод FillArray при помощи параметра ref. Некоторые из элементов массива обновляются в методе FillArray. Затем элементы массива отображаются в методе Main.
--
Implicitly Typed Arrays
You can create an implicitly-typed array in which the type of the array instance is inferred from the elements specified in the array initializer. The rules for any implicitly-typed variable also apply to implicitly-typed arrays.
Implicitly-typed arrays are usually used in query expressions together with anonymous types and object and collection initializers.
The following examples show how to create an implicitly-typed array:
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"}
};
}
}
|
In the previous example, notice that with implicitly-typed arrays, no square brackets are used on the left side of the initialization statement. Note also that jagged arrays are initialized by using new [] just like single-dimension arrays. Multidimensional implicitly-typed arrays are not supported.
Неявно типизированные массивы11
Можно создать неявно типизированный массив, в котором тип экземпляра массива получается из элементов, указанных в инициализаторе массива. Правила для неявно типизированной переменной также применяются к неявно типизированным массивам.
Неявно типизированные массивы обычно используются в выражениях запроса вместе с анонимными типами и инициализаторами объектов и коллекций.
В следующих примерах показано, как создать неявно типизированный массив:
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 []. Многомерные неявно типизированные массивы не поддерживаются.
Implicitly-typed Arrays in Object Initializers
When you create an anonymous type that contains an array, the array must be implicitly typed in the type's object initializer. In the following example, contacts is an implicitly-typed array of anonymous types, each of which contains an array named PhoneNumbers. Note that the var keyword is not used inside the object initializers.
var contacts = new[]
{
new {
Name = " Eugene Zabokritski",
PhoneNumbers = new[] { "206-555-0108", "425-555-0001" }
},
new {
Name = " Hanying Feng",
PhoneNumbers = new[] { "650-555-0199" }
}
};
|
Неявно типизированные массивы в инициализаторах объектов12
При создании анонимного типа, содержащего массив, этот массив неявно типизируется в инициализаторе объекта типа. В следующем примере contacts является неявно типизированным массивом анонимных типов, каждый из которых содержит массив с именем PhoneNumbers. Обратите внимание на то, что ключевое слово var внутри инициализаторов объектов не используется.
var contacts = new[]
{
new {
Name = " Eugene Zabokritski",
PhoneNumbers = new[] { "206-555-0108", "425-555-0001" }
},
new {
Name = " Hanying Feng",
PhoneNumbers = new[] { "650-555-0199" }
}
};
|
|
