Как найти размер массива си шарп

If it’s a one-dimensional array a,

a.Length

will give the number of elements of a.

If b is a rectangular multi-dimensional array (for example, int[,] b = new int[3, 5];)

b.Rank

will give the number of dimensions (2) and

b.GetLength(dimensionIndex)

will get the length of any given dimension (0-based indexing for the dimensions — so b.GetLength(0) is 3 and b.GetLength(1) is 5).

See System.Array documentation for more info.

As @Lucero points out in the comments, there is a concept of a «jagged array», which is really nothing more than a single-dimensional array of (typically single-dimensional) arrays.

For example, one could have the following:

int[][] c = new int[3][];
c[0] = new int[] {1, 2, 3};
c[1] = new int[] {3, 14};
c[2] = new int[] {1, 1, 2, 3, 5, 8, 13};

Note that the 3 members of c all have different lengths.
In this case, as before c.Length will indicate the number of elements of c, (3) and c[0].Length, c[1].Length, and c[2].Length will be 3, 2, and 7, respectively.

using System;

namespace geeksforgeeks {

class GFG {

    public static void Main()

    {

        int[, ] intarray = new int[, ] {{1, 2},

                                        {3, 4},

                                        {5, 6},

                                        {7, 8}};

        int[, ] intarray_d = new int[4, 2] {{ 1, 2}, 

                                             {3, 4}, 

                                             {5, 6},

                                             {7, 8}};

        int[,, ] intarray3D = new int[,, ] {{{ 1, 2, 3},

                                            { 4, 5, 6}},

                                            {{ 7, 8, 9},

                                         {10, 11, 12}}};

        int[,, ] intarray3Dd = new int[2, 2, 3] {{{1, 2, 3},

                                                 {4, 5, 6}},

                                                 {{ 7, 8, 9},

                                              {10, 11, 12}}};

        Console.Write("Total Number of Elements in intarray: ");

        Console.Write(intarray.Length);

        Console.Write("nTotal Number of Elements in intarray_d: ");

        Console.Write(intarray_d.Length);

        Console.Write("nTotal Number of Elements in intarray3D: ");

        Console.Write(intarray3D.Length);

        Console.Write("nTotal Number of Elements in intarray3Dd: ");

        Console.Write(intarray3Dd.Length);

    }

}

}

Массивы

Последнее обновление: 10.11.2021

Массив представляет набор однотипных данных. Объявление массива похоже на объявление переменной за тем исключением, что после указания типа ставятся квадратные скобки:

тип_переменной[] название_массива;

Например, определим массив целых чисел:

int[] numbers;

После определения переменной массива мы можем присвоить ей определенное значение:

int[] nums = new int[4];

Здесь вначале мы объявили массив nums, который будет хранить данные типа int. Далее используя операцию new,
мы выделили память для 4 элементов массива: new int[4]. Число 4 еще называется длиной массива.
При таком определении все элементы получают значение по умолчанию, которое предусмотренно для их типа. Для типа int значение по умолчанию — 0.

Также мы сразу можем указать значения для этих элементов:

int[] nums2 = new int[4] { 1, 2, 3, 5 };

int[] nums3 = new int[] { 1, 2, 3, 5 };

int[] nums4 = new[] { 1, 2, 3, 5 };

int[] nums5 = { 1, 2, 3, 5 };

Все перечисленные выше способы будут равноценны.

Подобным образом можно определять массивы и других типов, например, массив значений типа string:

string[] people = { "Tom", "Sam", "Bob" };

Индексы и получение элементов массива

Для обращения к элементам массива используются индексы. Индекс представляет номер элемента в массиве, при этом нумерация начинается с
нуля, поэтому индекс первого элемента будет равен 0, индекс четвертого элемента — 3.

Используя индексы, мы можем получить элементы массива:

int[] numbers = { 1, 2, 3, 5 };

// получение элемента массива
Console.WriteLine(numbers[3]);  // 5

// получение элемента массива в переменную
var n = numbers[1]; 	// 2
Console.WriteLine(n);  // 2

Также мы можем изменить элемент массива по индексу:

int[] numbers = { 1, 2, 3, 5 };

// изменим второй элемент массива
numbers[1] = 505;

Console.WriteLine(numbers[1]);  // 505

И так как у нас массив определен только для 4 элементов, то мы не можем обратиться, например, к шестому элементу.
Если мы так попытаемся сделать, то мы получим ошибку во время выполнения:

int[] numbers = { 1, 2, 3, 5 };

Console.WriteLine(numbers[6]);  // ! Ошибка - в массиве только 4 элемента

Свойство Length и длина массива

каждый массив имеет свойство Length, которое хранит длину массива. Например, получим длину выше созданного массива numbers:

int[] numbers = { 1, 2, 3, 5 };

Console.WriteLine(numbers.Length);  // 4

Для получения длины массива после названия массива через точку указывается свойство Length: numbers.Length.

Получение элементов с конца массива

Благодаря наличию свойства Length, мы можем вычислить индекс последнего элемента массива — это длина массива — 1. Например, если длина массива — 4 (то есть
массив имеет 4 элемента), то индекс последнего элемента будет равен 3. И, используя свойство Length, мы можем легко получить элементы с конца массива:

int[] numbers = { 1, 2, 3, 5};

Console.WriteLine(numbers[numbers.Length - 1]);  // 5 - первый с конца или последний элемент
Console.WriteLine(numbers[numbers.Length - 2]);  // 3 - второй с конца или предпоследний элемент
Console.WriteLine(numbers[numbers.Length - 3]);  // 2 - третий элемент с конца

Однако при подобном подходе выражения типа numbers.Length - 1, смысл которых состоит в том, чтобы получить какой-то определенный элемент с конца массива,
утяжеляют код. И, начиная, с версии C# 8.0 в язык был добавлен специальный оператор ^,
с помощью которого можно задать индекс относительно конца коллекции.

Перепишем предыдущий пример, применяя оператор ^:

int[] numbers = { 1, 2, 3, 5};

Console.WriteLine(numbers[^1]);  // 5 - первый с конца или последний элемент
Console.WriteLine(numbers[^2]);  // 3 - второй с конца или предпоследний элемент
Console.WriteLine(numbers[^3]);  // 2 - третий элемент с конца

Перебор массивов

Для перебора массивов мы можем использовать различные типы циклов. Например, цикл foreach:

int[] numbers = { 1, 2, 3, 4, 5 };
foreach (int i in numbers)
{
    Console.WriteLine(i);
}

Здесь в качестве контейнера выступает массив данных типа int. Поэтому мы объявляем переменную с типом int

Подобные действия мы можем сделать и с помощью цикл for:

int[] numbers = { 1, 2, 3, 4, 5 };
for (int i = 0; i < numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);
}

В то же время цикл for более гибкий по сравнению с foreach. Если foreach последовательно извлекает элементы контейнера и только для чтения,
то в цикле for мы можем перескакивать на несколько элементов вперед в зависимости от приращения счетчика, а также можем изменять элементы:

int[] numbers = { 1, 2, 3, 4, 5 };
for (int i = 0; i < numbers.Length; i++)
{
	numbers[i] = numbers[i] * 2;
    Console.WriteLine(numbers[i]);
}

Также можно использовать и другие виды циклов, например, while:

int[] numbers = { 1, 2, 3, 4, 5 };
int i = 0;
while(i < numbers.Length)
{
    Console.WriteLine(numbers[i]);
	i++;
}

Многомерные массивы

Массивы характеризуются таким понятием как ранг или количество измерений. Выше мы рассматривали
массивы, которые имеют одно измерение (то есть их ранг равен 1) — такие массивы можно представлять в виде ряда (строки или столбца) элемента.
Но массивы также бывают многомерными. У таких массивов количество измерений (то есть ранг) больше 1.

Массивы которые имеют два измерения (ранг равен 2) называют двухмерными. Например, создадим одномерный и двухмерный массивы, которые имеют одинаковые элементы:

int[] nums1 = new int[] { 0, 1, 2, 3, 4, 5 };

int[,] nums2 = { { 0, 1, 2 }, { 3, 4, 5 } };

Визуально оба массива можно представить следующим образом:

Одномерный массив nums1

0

1

2

3

4

5

Двухмерный массив nums2

Поскольку массив nums2 двухмерный, он представляет собой простую таблицу. Все возможные способы определения двухмерных массивов:

int[,] nums1;
int[,] nums2 = new int[2, 3];
int[,] nums3 = new int[2, 3] { { 0, 1, 2 }, { 3, 4, 5 } };
int[,] nums4 = new int[,] { { 0, 1, 2 }, { 3, 4, 5 } };
int[,] nums5 = new [,]{ { 0, 1, 2 }, { 3, 4, 5 } };
int[,] nums6 = { { 0, 1, 2 }, { 3, 4, 5 } };

Массивы могут иметь и большее количество измерений. Объявление трехмерного массива могло бы выглядеть так:

int[,,] nums3 = new int[2, 3, 4];

Соответственно могут быть и четырехмерные массивы и массивы с большим количеством измерений. Но на практике
обычно используются одномерные и двухмерные массивы.

Определенную сложность может представлять перебор многомерного массива. Прежде всего надо учитывать, что длина такого массива — это совокупное количество элементов.

int[,] numbers = { { 1, 2, 3 }, { 4, 5, 6 }};
foreach (int i in numbers)
	Console.Write($"{i} ");

В данном случае длина массива numbers равна 6. И цикл foreach выводит все элементы массива в строку:

Но что если мы хотим отдельно пробежаться по каждой строке в таблице? В этом случае надо получить количество элементов в размерности.
В частности, у каждого массива есть метод GetUpperBound(номер_размерности), который возвращает индекс последнего
элемента в определенной размерности. И если мы говорим непосредственно о двухмерном массиве, то первая размерность (с индексом 0)
по сути это и есть таблица. И с помощью выражения

numbers.GetUpperBound(0) + 1

можно получить количество строк таблицы, представленной двухмерным массивом. А через

numbers.Length / количество_строк

можно получить количество элементов в каждой строке:

int[,] numbers = { { 1, 2, 3 }, { 4, 5, 6 }};

int rows = numbers.GetUpperBound(0) + 1;	// количество строк
int columns = numbers.Length / rows;		// количество столбцов
// или так
// int columns = numbers.GetUpperBound(1) + 1;

for (int i = 0; i < rows; i++)
{
	for (int j = 0; j < columns; j++)
	{
		Console.Write($"{numbers[i, j]} t");
	}
	Console.WriteLine();
}

Массив массивов

От многомерных массивов надо отличать массив массивов или так называемый «зубчатый массив»:

int[][] nums = new int[3][];
nums[0] = new int[2] { 1, 2 };			// выделяем память для первого подмассива
nums[1] = new int[3] { 1, 2, 3 };		// выделяем память для второго подмассива
nums[2] = new int[5] { 1, 2, 3, 4, 5 };	// выделяем память для третьего подмассива

Здесь две группы квадратных скобок указывают, что это массив массивов, то есть такой массив, который в свою очередь содержит в себе
другие массивы. Причем длина массива указывается только в первых квадратных скобках, все последующие квадратные скобки должны быть пусты:
new int[3][]. В данном случае у нас массив nums содержит три массива. Причем размерность каждого из этих массивов может не совпадать.

Альтернативное определение массива массивов:

int[][] numbers = { 
    new int[] { 1, 2 }, 
    new int[] { 1, 2, 3 }, 
    new int[] { 1, 2, 3, 4, 5 } 
};

Зубчатый массив nums

1	2
1	2	3
1	2	3	4	5

Используя вложенные циклы, можно перебирать зубчатые массивы. Например:

int[][] numbers = new int[3][];
numbers[0] = new int[] { 1, 2 };
numbers[1] = new int[] { 1, 2, 3 };
numbers[2] = new int[] { 1, 2, 3, 4, 5 };
foreach(int[] row in numbers)
{
	foreach(int number in row)
    {
		Console.Write($"{number} t");
    }
	Console.WriteLine();
}

// перебор с помощью цикла for
for (int i = 0; i<numbers.Length;i++)
{
	for (int j =0; j<numbers[i].Length; j++)
    {
		Console.Write($"{numbers[i][j]} t");
	}
	Console.WriteLine();
}

Основные понятия массивов

Суммируем основные понятия массивов:

• Ранг (rank): количество измерений массива

• Длина измерения (dimension length): длина отдельного измерения массива

• Длина массива (array length): количество всех элементов массива

Например, возьмем массив

int[,] numbers = new int[3, 4];

Массив numbers двухмерный, то есть он имеет два измерения, поэтому его ранг равен 2. Длина первого измерения — 3, длина второго измерения — 4. Длина массива (то есть общее количество элементов) — 12.

Примеры массивов:

В этом посте мы обсудим, как найти длину массива в C#.

1. Использование Array.Length Имущество

Стандартным решением для нахождения длины массива является использование Array.Length имущество. Он возвращает общее количество элементов, содержащихся в массиве. Если массив пуст, возвращается ноль. Следующий пример демонстрирует это:

Скачать  Выполнить код

результат:

Length is 5

 
Для многомерных массивов Array.Length возвращает общее количество элементов во всех измерениях. Другими словами, он возвращает сумму общего количества элементов в каждом измерении многомерного массива.

Скачать  Выполнить код

результат:

Length is 6

 
В C#, зубчатый массив могут быть разных размеров и размеров. Для зубчатого массива Length свойство будет указывать количество измерений в массиве. Например,

Скачать  Выполнить код

результат:

array.Length is 3
array[0].Length is 2
array[1].Length is 3
array[2].Length is 4

2. Использование Array.GetLength(Int32) Метод

В качестве альтернативы вы можете использовать Array.GetLength() метод для получения длины одномерного массива. Идея состоит в том, чтобы передать нулевое измерение GetLength метод для определения общего количества элементов в первом измерении массива.

Скачать  Выполнить код

результат:

Length is 5

 
Если массив многомерный, то Array.GetLength() Метод возвращает общее количество элементов в указанном измерении многомерного массива.

Скачать  Выполнить код

результат:

Length is 2

3. Использование Array.Rank Имущество

Если вам нужно количество измерений массива вместо количества элементов, используйте Array.Rank Имущество. Он возвращает 1 для одномерного массива и зубчатого массива (массив массивов), 2 для двумерного массива и так далее.

Скачать  Выполнить код

результат:

Rank is 2

4. Использование foreach

Другой возможный, но менее рекомендуемый вариант — вручную подсчитать количество элементов в массиве. В следующем примере показано, как использовать цикл foreach и переменную счетчика для достижения того же.

Скачать  Выполнить код

результат:

Length is 5

Вот и все, что касается нахождения длины массива в C#.

I’m not sure what part you are stuck with so I shall explain all the parts I think I can see.

It looks like you are looking for the indexer syntax on arrays.

The code you may want is:

if (NewArray.Length == 3 && NewArray[1].ToLower() == "dddd")

Note the square brackets [] indexing into the array. Regular C# arrays exposes an int indexer. Once indexed, the dot-notation will give you access to the type inside the array, here I assume that the array is a string[], hence we can do NewArray[1].<string members here>.

Note also that array indexing in C# is zero-based, so 0 is the first element of the array and NewArray.Length - 1 is the last element. Your [1] may not be correct unless of course you intend on accessing the second array item.

As a side note, using ToLower is not the only way to get case-insensitive comparisons, you can also do the following:

string.Compare(NewArray[1], "dddd", true) == 0

The string.Compare documentation shows the ignoreCase argument. I’m not in any way trying to say my suggestion is best practice.