Массивы
Массив представляет собой совокупность переменных одного типа с общим для обращения к ним именем. В C# массивы могут быть как одномерными, так и многомерными. Массивы служат самым разным целям, поскольку они предоставляют удобные средства для объединения связанных вместе переменных.
Массивами в C# можно пользоваться практически так же, как и в других языках программирования. Тем не менее у них имеется одна особенность: они реализованы в виде объектов.
Для тoго чтобы воспользоваться массивом в программе, требуется двухэтапная процедура, поскольку в C# массивы реализованы в виде объектов. Во-первых, необходимо объявить переменную, которая может обращаться к массиву. И во-вторых, нужно создать экземпляр массива, используя оператор new.
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 < class Program < static void Main(string[] args) < // Объявляем массив int[] myArr = new int[5]; // Инициализируем каждый элемент массива вручную myArr[0] = 100; myArr[1] = 23; myArr[2] = 25; myArr[3] = 31; myArr[4] = 1; foreach (int i in myArr) Console.WriteLine(i); Console.ReadLine(); >> >Следует иметь в виду, что если массив только объявляется, но явно не инициализируется, каждый его элемент будет установлен в значение, принятое по умолчанию для соответствующего типа данных (например, элементы массива типа bool будут устанавливаться в false, а элементы массива типа int — в 0).
Инициализация массива
Помимо заполнения массива элемент за элементом (как показано в предыдущем примере), можно также заполнять его с использованием специального синтаксиса инициализации массивов. Для этого необходимо перечислить включаемые в массив элементы в фигурных скобках < >. Такой синтаксис удобен при создании массива известного размера, когда нужно быстро задать его начальные значения:
// Синтаксис инициализации массива с использованием // ключевого слова new int[] myArr = new int[] ; // Синтаксис инициализации массива без использования // ключевого слова new string[] info = < "Фамилия", "Имя", "Отчество" >; // Используем ключевое слово new и желаемый размер char[] symbol = new char[4] < 'X','Y','Z','M' >;Обратите внимание, что в случае применения синтаксиса с фигурными скобками размер массива указывать не требуется (как видно на примере создания переменной myArr), поскольку этот размер автоматически вычисляется на основе количества элементов внутри фигурных скобок. Кроме того, применять ключевое слово new не обязательно (как при создании массива info).
Неявно типизированные массивы
Ключевое слово var позволяет определить переменную так, чтобы лежащий в ее основе тип выводился компилятором. Аналогичным образом можно также определять неявно типизированные локальные массивы. С использованием такого подхода можно определить новую переменную массива без указания типа элементов, содержащихся в массиве. Давайте рассмотрим пример:
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 < class Program < static void Main(string[] args) < var arr1 = new[] < 1, 2, 3 >; Console.WriteLine("Тип массива arr1 - ",arr1.GetType()); var arr2 = new[] < "One", "Two", "Three" >; Console.WriteLine("Тип массива arr2 - ",arr2.GetType()); Console.ReadLine(); > > > 
Разумеется, как и при создании массива с использованием явного синтаксиса C#, элементы, указываемые в списке инициализации массива, должны обязательно иметь один и тот же базовый тип (т.е. должны все быть int, string или MyCar).
Определение массива объектов
В большинстве случаев при определении массива тип элемента, содержащегося в массиве, указывается явно. Хотя на первый взгляд это выглядит довольно понятно, существует одна важная особенность. В основе каждого типа в системе типов .NET (в том числе фундаментальных типов данных) в конечном итоге лежит базовый класс System.Object. В результате получается, что в случае определения массива объектов находящиеся внутри него элементы могут представлять собой что угодно:
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 < class Program < static void Main(string[] args) < // Объявляем и инициализируем массив объектов object[] arrByObject = < true, 10, "Привет", 13.7m >; // Выведем в консоль тип каждого члена массива foreach (object me in arrByObject) Console.WriteLine("Тип - ",me,me.GetType()); Console.ReadLine(); > > >
Свойство Length
Реализация в C# массивов в виде объектов дает целый ряд преимуществ. Одно из них заключается в том, что с каждым массивом связано свойство Length, содержащее число элементов, из которых может состоять массив. Следовательно, у каждого массива имеется специальное свойство, позволяющее определить его длину.
Когда запрашивается длина многомерного массива, то возвращается общее число элементов, из которых может состоять массив. Благодаря наличию у массивов свойства Length операции с массивами во многих алгоритмах становятся более простыми, а значит, и более надежными. Давайте рассмотрим пример использования свойства Length:
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 < class Program < static void Main(string[] args) < int[] myArr = < 1, 2, 3, 4 >; for (int i = 0; i < myArr.Length; i++) Console.WriteLine(myArr[i]); Console.ReadLine(); >> >C#. Урок 8. Массивы
Одной из наиболее часто используемых структур данных является массив. О том как работать с массивами в C# вы узнаете в этом уроке.
- Объявление массивов и инициализация массивов
- Объявление массивов
- Инициализация массивов
- Неявная типизация
- Прямоугольные массивы
- Зубчатые массивы
Исходный код примеров из этой статьи можете скачать из нашего github-репозитория.
Объявление массивов и инициализация массивов
Объявление массивов
Массив – это структура данных для хранения элементом определенного типа, имеющая фиксированный размер. Доступ к элементам массива производится по числовому индексу.
Для объявления массива, после указания типа его элементов, ставятся квадратные скобки:
int[] a1; // массив типа int
Перед использованием, массив обязательно нужно проинициализировать, это можно сделать сразу, при его объявлении:
int[] na2 = new int[5]; // массив из пяти элементов типа int
Либо после объявления:
int[] na3; na3 = new int[5]; // массив из пяти элементов типа int
Для доступа к элементам массива используются числовые индексы. Значения элементов массива будут равны значению по умолчанию для типа, массив которого был создан.
Например, для указанного выше a3 – это будут нули, так как для типа int значение по умолчанию: 0;
Console.WriteLine(na3[0]); // значение: 0 Console.WriteLine(na3[1]); // значение: 0
Если попытаться вывести элементы массива na1 :
Console.WriteLine(na1[0]); // ошибка компиляции
то приложение не будет собрано, т.к. массив предварительно нужно проинициализировать.
Инициализация массивов
Рассмотрим различные варианты инициализации массива. Как уже было сказано, можно просто указать количество элементов в массиве, при этом его элементам будут присвоены значения по умолчанию:
bool[] ba1 = new bool[3]; Console.WriteLine("ba1[0]: " + ba1[0].ToString());После объявления массива значения элементам присваиваются через индекс:
string[] sa1 = new string[3]; sa1[0] = "abc"; sa1[1] = "def"; sa1[2] = "ghi"; Console.WriteLine($"sa1: , , ");
Есть возможность задать конкретные значения в момент объявления с использованием ключевого слова new и указанием типа:
double[] da1 = new double[3] ; Console.WriteLine($"da1: , , ");
Либо без ключевого слова new:
double[] da2 = ; Console.WriteLine($"da2: , , ");
Неявная типизация
При объявлении массива можно воспользоваться ключевым словом var . При этом тип элементов массива следует задать явно в правой части объявления:
var va2 = new string[3]; va2[0] = "John"; va2[1] = "Mary"; va2[2] = "Mike"; Console.WriteLine($"va2: , , ");
Либо предоставить возможность “поработать” системе вывода типов:
var va1 = new[] ; Console.WriteLine($"va1: , , ");
Доступ к элементам массива. Обход элементов массива.
Как уже было сказано выше, за доступ к элементам массива отвечают числовые индексы:
int[] na4 = ; Console.WriteLine($"na4[0]: ");
При этом, если вы укажете индекс больше, чем максимально возможный, то будет выброшено исключение:
Console.WriteLine($"na4[10]: ");
Приведенная выше строка приведет к выбросу следующего исключения:
Unhandled exception. System.IndexOutOfRangeException: Index was outside the bounds of the array .
Обход элементов массива можно производить с помощью циклов for , foreach и while , последний самый неудобный для работы с массивами, его мы рассматривать не будем. Если вы работаете с циклом for , то для указания верхней границы инкрементируемой переменной можно воспользоваться свойством Length у массива:
for(int i = 0; i < na4.Length; i++) < Console.Write(na4[i].ToString() + " "); >// 1 2 3 4 5
Более удобным для обхода элементов будет foreach :
foreach(var v in na4) < Console.Write(v.ToString() + " "); >// 1 2 3 4 5
Преимущество цикла for состоит в том, что в нем вы можете модифицировать элементы массива:
for(int i = 0; i < na4.Length; i++) < na4[i] = (na4[i] + 3) * 10; Console.Write(na4[i].ToString() + " "); >// 40 50 60 70 80
Передача массива в метод
Массивы являются ссылочным типом данных, это означает, что их значения хранятся в куче, а имя переменной массива является ссылкой на соответствующую область памяти. При передаче массива в качестве аргумента в метод, происходит присваивание значения переменной массива переменной определяющей аргумент, а так как имя массива – это ссылка, то фактически происходит передача ссылки на значение в куче. Поэтому, если вы передали массив в функцию и внутри этой функции произошла модификация этого массива, то исходный массив тоже изменится.
Создадим метода WorkWithArray , который изменяет содержимое массива:
public static void WorkWithArray(int[] arr)
Вызовем его в методе Main :
int[] na5 = ; foreach(var v in na5) // 1 2 3 4 5 Console.Write(v + " "); Console.WriteLine(); WorkWithArray(na5); foreach(var v in na5) // 123 2 3 4 5 Console.Write(v + " ");
Ниже приведена иллюстрация того, как массив и ссылки на него располагаются в памяти.
Переменные na5 в методе Main и arr в методе WorkWithArray ссылаются на одну и ту же область памяти в куче, поэтому изменение массива через переменную arr отражается на переменной na5 .
Многомерные массивы
Массивы имеющее более одного измерения называются многомерными. До этого мы работали с одномерными массивами. В C# предлагается к использованию два вида многомерных массивов: прямоугольные и зубчатые, которые иногда называются массивы массивов.
Прямоугольные массивы
Прямоугольные массивы могут содержать несколько измерений (два и более), при этом количество элементов в каждом подизмерении (в каждой строке) одинаково.
Рассмотрим на примерах работу с такими массивами:
double[,] dm1 = new double[3, 3]; for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) dm1[i, j] = i + j; for (int i = 0; i < 3; i++) < for (int j = 0; j < 3; j++) Console.Write($"
Зубчатые массивы
В зубчатых массивах элементами верхнего уровня являются другие массивы, это позволяет создавать многомерные структуры, у которых строки имеют разную длину:
int[][] nm1 = new int[3][]; for(int i = 0; i < nm1.Length; i++) nm1[i] = new int[i+1]; for(int i = 0; i < nm1.Length; i++) < for(int j = 0; j < nm1[i].Length; j++) Console.Write($""); Console.WriteLine(); >
Класс System.Array
Класс System.Array является базовым для всех массивов, это позволяет использовать свойства и методы данного класса при работе с массивом. Ниже в таблицах приведены некоторые полезные свойства и методы из System.Array , более полную информацию вы можете найти в официальной документации Microsoft ( https://docs.microsoft.com/ru-ru/dotnet/api/system.array ).
Свойства класса System.Array
Имя свойства
Назначение
Число элементов в массиве. Учитываются все измерения.
Ранг массива – число измерений.
int[] na6 = ; int[,] nm2 = < , >; int[][] nm3 = new int[3][]; for(int i = 0; i < nm3.Length; i++) nm3[i] = new int[i+1]; Console.WriteLine($"na6: Length=, Rank="); // na6: Length=7, Rank=1 Console.WriteLine($"nm2: Length=, Rank="); // nm2: Length=6, Rank=2 Console.WriteLine($"nm3: Length=, Rank="); // nm3: Length=3, Rank=1
Методы класса System.Array
Символ * после названия метода означает, что он имеет более одной сигнатуры, за дополнительной информацией обращайтесь к официальной документации.
Имя метода
Назначение
BinarySearch(Array, Object)*
Выполняет поиск элемента в массиве.
Clear(Array, Int32, Int32)
Присваивает значение по умолчанию определенному количеству элементов массива начиная с заданного индекса.
Создает копию массива (неполную).
Copy(Array, Array, Int32)*
Копирует данные из одного массива в другой в заданном количестве.
CopyTo(Array, Int32)*
Копирует элементы из текущего массива в заданный, начиная с указанного индекса.
Exists(T[], Predicate)
Определяет наличие элемента удовлетворяющему предикату.
GetValue(Int32)*
Возвращает значение по указанному индексу.
IndexOf(Array, Object)*
Возвращает индекс первого вхождения элемента в массиве.
Reverse(Array)*
Задает обратный порядок для элементов в массиве.
Сортирует элементы массива.
Для вывода содержимого массива в консоль создадим метод PrintArray :
public static void PrintArray(string txt, T[] arr) < Console.Write($": "); foreach(var v in arr) < Console.Write($""); > >
Ниже приведены примеры использования представленных выше методов и свойств класса System.Array :
int[] na6 = ; int[,] nm2 = < , >; int[][] nm3 = new int[3][]; for(int i = 0; i < nm3.Length; i++) nm3[i] = new int[i+1]; Console.WriteLine($"na6: Length=, Rank="); // na6: Length=7, Rank=1 Console.WriteLine($"nm2: Length=, Rank="); // nm2: Length=6, Rank=2 Console.WriteLine($"nm3: Length=, Rank="); // nm3: Length=3, Rank=1 Console.WriteLine("BinarySearch result: " + Array.BinarySearch(na6, 5).ToString()); // BinarySearch result: 4 var na7 = (int[])na6.Clone(); Array.Clear(na7, 2, 2); PrintArray("na6", na6); // na6: 1 2 3 4 5 6 7 PrintArray("na7", na7); // na7: 1 2 0 0 5 6 7 Array.Copy(na7, na6, 4); PrintArray("na6 after copy", na6); // na6 after copy: 1 2 0 0 5 6 7 (new int[]).CopyTo(na6, 0); PrintArray("na6", na6); // na6: 1 2 3 4 5 6 7 var ans = Array.Exists(na6, v => (v % 2) == 0); Console.WriteLine($"Is even number exists in na6? Answer: "); Array.Fill(na7, 7); PrintArray("na7", na7); // na7: 7 7 7 7 7 7 7 Console.WriteLine($"Value at 3 index in na6: "); Console.WriteLine($"Index of value=5 in na6:Исходный код примеров из этой статьи можете скачать из нашего github-репозитория.
Раздел: .NET / C# Уроки по C# Метки: .NET, C#, Уроки по C#
C#. Урок 8. Массивы : 3 комментария
- Аноним 03.05.2022 А как создать публичный массив?
- Антон 13.04.2023 Для создания публичного массива в C# нужно использовать модификатор доступа `public` перед типом массива и перед именем переменной массива, которую вы хотите создать. Например: “`
public int[] myPublicArray = new int[10];
“` В данном примере мы создаем публичный массив `myPublicArray`, состоящий из 10 элементов типа `int`. Теперь этот массив будет доступен для использования из любого места вашей программы
Массивы в C#: Все что необходимо знать
Массивы — это одна из основных конструкций в программировании, которая позволяет хранить набор элементов одного типа. В C#, массивы используются повсеместно благодаря своей простоте и эффективности. В этой статье мы подробно разберём, что такое массивы в C#, как их создавать, использовать и какие операции с ними можно выполнять.
Что такое массив?
Массив в C# — это коллекция элементов одного типа, хранящихся в памяти непрерывно, где каждый элемент имеет индекс. Индексация начинается с нуля.
Объявление массива
int[] myArray;Здесь мы объявили массив целых чисел myArray , но пока что он не содержит ни одного элемента.
Инициализация массива
Статическая инициализация:
int[] myArray = new int[5]; // Массив из 5 элементовИнициализация с набором значений:
int[] myArray = < 1, 2, 3, 4, 5 >;Работа с элементами массива
Доступ к элементам массива осуществляется по индексу:
int[] myArray = < 1, 2, 3, 4, 5 >; int firstElement = myArray[0]; // 1 int thirdElement = myArray[2]; // 3Индексы в массиве начинаются с 0, так что myArray[0] возвращает первый элемент.
Изменение элементов
myArray[3] = 100; // Меняем четвертый элемент массива на 100Особенности массивов в C
Размер массива
Размер массива в C# фиксирован после создания. Вы не можете увеличить или уменьшить его после инициализации. Для динамически изменяемых коллекций используются другие типы, например List .
Перебор элементов массива
Для перебора элементов массива обычно используют циклы, такие как for или foreach :
foreach (int item in myArray) < Console.WriteLine(item); >Многомерные массивы
В C# есть поддержка многомерных массивов. Есть два типа: прямоугольные и ступенчатые (jagged).
Читайте так же Наследование в C# простым языком: 4 наглядных примера
Прямоугольные массивы:
int[,] matrix = new int[2, 3];Такой массив представляет собой матрицу 2×3.
Ступенчатые массивы:
int[][] jaggedArray = new int[3][]; jaggedArray[0] = new int[2]; jaggedArray[1] = new int[3]; jaggedArray[2] = new int[4];Каждый ‘ряд’ такого массива может иметь разную длину.
Полезные операции с массивами
- Длина массива: свойство Length возвращает количество элементов в массиве.
- Сортировка: метод Array.Sort(myArray) сортирует массив по возрастанию.
- Поиск: метод Array.Find(myArray, условие) помогает найти элемент, соответствующий условию.
- Копирование: Array.Copy(sourceArray, destinationArray, length) используется для копирования элементов из одного массива в другой.
Заключение
Массивы в C# — это мощный и гибкий инструмент. Хоть их размер и фиксирован после создания, они обеспечивают высокую производительность за счет непрерывного расположения элементов в памяти. Используйте массивы для структурированного хранения данных, когда вы заранее знаете их количество и вам необходим быстрый доступ к элементам по индексу.
Эта статья является лишь вводным руководством в мир массивов C#. Существует множество продвинутых тем и техник работы с массивами, включая многомерные массивы, обработку и трансформацию данных, которые вы сможете изучить по мере погружения в язык.
Массивы в C#
уважаемые посетители блога, если Вам понравилась, то, пожалуйста, помогите автору с лечением. Подробности тут.
На данный момент мы знаем, что такое переменная, как задаётся её тип и как переменную инициализировать. Теперь, когда мы знаем какие виды циклов имеются в C# и в чём их отличия, можно детально изучать вопросы, связанные с использованием массивов C#.
Что такое «массив»? Зачем нужны массивы?
Допустим, вам необходимо хранить в программе 10 целочисленных значений. С одной стороны, если вам не лень (и не жалко тех, кто будет смотреть Ваш код) вы можете объявить 10 переменных типа int , инициализировать их и работать. А что делать, если требуется 100 значений или 1000? Опять же, можно сходить с ума и заводить под каждое значение отдельную переменную, а можно сделать проще — объявить переменную-массив и хранить в ней все значения.
Массив — это структура данных, которая содержит ряд переменных одного типа, доступ к которым осуществляется по индексу. Массивы в C# могут быть одномерными, многомерными, пустыми, также в C# массивы могут быть зубчатыми (массивы массивов). Но обо всём по порядку.
Как создать массив в C#
Чтобы объявить массив в C# необходимо использовать следующую конструкцию:
Type[] ArrayName
где Type — это тип элементов массива, а ArrayName — его имя. То есть, визуально, массив от обычной переменной отличает наличие после названия типа данных квадратных скобок [] . Например, вот так можно определить массив целых чисел типа int :
int[] array;
Так, можно объявить массивы строк и вещественных чисел:
double[] doubleArray; string[] stringArray;
Как мы уже знаем, объявить переменную — это только часть работы. Переменную необходимо инициализировать. При всех своих возможностях, C# не может знать сколько элементов будет содержать наш массив — 0, 10, 1000 и так далее. Сами массивы имеют ссылочный тип, и объявление переменной массива только выделяет память для ссылки на экземпляр массива. Фактические экземпляры массива создаются динамически во время выполнения с помощью оператора new . Операция new указывает длину нового экземпляра массива, которая остается неизменной в течение всего времени существования этого экземпляра.
Например, создадим массив, который будет хранить 5 чисел типа int :
int[] intArray = new int[5];
Теперь у нас есть экземпляр массива, который может хранить пять чисел. По умолчанию C# задал каждому элементу значение 0 (ноль). Проверить это легко с помощью уже известного нам цикла foreach :
int[] intArray = new int[5]; foreach (int i in intArray)
Если создается массив, содержащий элементы ссылочного типа, то всем элементам по умолчанию будет присвоено значение null . Чтобы задать каждому элементу массива свое значение можно обратиться к нему по его индексу. В C# элементы массива получают индексы от 0 до значение длина-1 . Для нашего массива задать элементы можно вот так:
intArray[0] = 10; //задаем значение первого элемента intArray[1] = 7; //задаем значение второго элемента intArray[2] = -3; //задаем значение третьего элемента intArray[3] = 18; //задаем значение четвертого элемента intArray[4] = -125; //задаем значение пятого элемента
Язык C# достаточно гибкий, поэтому разработчики языка предусмотрели и тот вариант, что уже на этапе создания массива вы можете знать какие значения будут содержать его элементы, в этом случае, мы можем использовать такую конструкцию:
int[] intArray = new int[5] < 10, 7, -3, 18, -125>;
Здесь мы объявили переменную-массив, инициализировали её и сразу задали каждому элементы своё значение. Оба варианта: и задание значения каждому элементу в по-отдельности и как в примере выше полностью равнозначны. Но и на этом разработчики C# не остановились, чтобы дать разработчику максимум удобства работы с этим языком программирования. Ниже я покажу какие ещё варианты создания массивов могут применяться в C# на примере всё того же массива из пяти чисел:
int[] intArray2 = new int[] < 10, 7, -3, 18, -125 >; int[] intArray3 = new[] < 10, 7, -3, 18, -125 >; int[] intArray4 = < 10, 7, -3, 18, -125 >; int[] intArray5 = [10, 7, -3, 18, -125]; //вариант доступен в C# 12 и .NET 8
Итого — целых шесть возможных вариантов того, как задать массив в C#.
Перебор элементов одномерного массива в C#
В цикле foreach
Выше я показал один из способов как перебрать элементы массива с использованием цикла foreach :
int[] intArray = new int[5] < 10, 7, -3, 18, -125>;//создали массив //перебираем все элементы массива foreach (int i in intArray)
Здесь в цикле foreach мы указали тип элементов int , так как у нас массив содержит элементы этого типа и после ключевого слова in указали массив элементы которого необходимо перебрать. Если бы у нас был массив строк, то цикл выглядел бы, соответственно, следующим образом:
//создаем массив string[] strAttay = < "Один", "Два", "Три">; //перебираем элементы foreach (string i in strArray)
Цикл foreach достаточно удобный для работы, но иногда бывает так, что возможностей цикла не достаточно. Например, мы создаем массив и нам требуется обеспечить доступ только к элементам с чётными индексами (0, 2, 4, 6 и т.д.). Технически, мы можем использовать тот же foreach , ввести дополнительную переменную и с помощью неё проверять какой индекс у очередного элемента, но это усложнит наш код. Более гибким в этом плане является цикл for в котором мы можем задавать порядок выполнения.
В цикле for
С этим циклом мы тоже уже знакомы. Попробуем реализовать озвученный выше вариант перебора элементов массива — прочитать значения только элементов с чётными индексами. С циклом for это можно сделать, например, вот так:
//Индексы элементов 0 1 2 3 4 5 6 7 8 9 10 int[] intArray = new int[11] < 12, 7, 16, 17, -12, 65, 80, 89, 90, 91, 102>; for (int i=0; i. Читаем элемент с индексом значение:
Вывод консоли будет выглядеть следующим образом:
Счётчик цикла: 0. Читаем элемент с индексом 0 значение: 12
Счётчик цикла: 1. Читаем элемент с индексом 2 значение: 16
Счётчик цикла: 2. Читаем элемент с индексом 4 значение: -12
Счётчик цикла: 3. Читаем элемент с индексом 6 значение: 80
Счётчик цикла: 4. Читаем элемент с индексом 8 значение: 90
Счётчик цикла: 5. Читаем элемент с индексом 10 значение: 102
Условие в теле цикла:
if (i*2
Требуется для того, чтобы мы не вышли за границы массива. Так, уже на шестом шаге цикла мы бы получили то, что должны прочитать элемент с индексом 6*2=12 которого не существует (максимальный индекс у нас в примере — 10 ) и программа бы выдала нам исключение:
System.IndexOutOfRangeException
Сообщение = Index was outside the bounds of the array.
Выход за границы массива. Поэтому мы и обезопасили себя от этого исключения сделав проверку — элемент массива с каким индексом мы пытаемся проверить, а сам цикл закончился аккурат на пятом шаге.
В приведенном выше примере остается ещё один, возможно, непонятный для новичков в C# момент, а именно, условие выхода из цикла:
Что за Length ? Забегая немного вперед, скажу, что это свойство массива, определяющее общее количество элементов массива по всем его измерениям. Чтобы получить значение этого свойства необходима написать имя массива, на клавиатуре точку ( . ) и в списке выбрать Length . О том, как такая «магия» работает в C# мы поговорим позднее. А пока перейдем к дальнейшей работе с массивами.
Многомерные массивы
До сих пор мы имели дело с так называемыми одномерными массивами, которые можно себе представить в уме как ряд переменных (числовых, строковых, символьных и т.д.). Визуально, наши одномерные массивы выглядели так:
Однако, на одном измерении массива C# не заканчивается. Теоретически мы можем задать массив с любым количеством измерений (которые кстати, называются рангом), но на практике, обычно встречаются одно-, двух- и намного реже — трехмерные массивы. Образно, двумерный массив можно представить как обычную таблицу, а трехмерный массив — как куб переменных. Например, чтобы задать двумерный массив чисел (ранг = 2), необходима сделать вот такое объявление переменной:
int[,] TwoDimArray;
обратите внимание на запятую в квадратных скобках. В C# существует простое правило: ранг массива всегда на единицу больше количества запятых в квадратных скобках. Массив с рангом равным 3 (трехмерный) будет объявляться так:
int[,,] ThreeDimArray;
Инициализируются многомерные массивы точно также, как и одномерные — необходимо задать количество элементов в каждом измерении. Например, зададим массив состоящий из двух столбцов и пяти строк:
int[,] array = new int[5, 2] < < 0, 1 >, < 2, 3 >, < 4, 5 >, < 6, 7 >, < 8, 9 >>;
Теперь, чтобы обратиться как какому-либо элементу массива, нам необходимо указывать два индекса — индекс строки и индекс столбца. Например, получим значение из четвертой строки второго столбца. Так как нумерация элементов в массивах начинается с нуля, то код будет такой:
Console.WriteLine(array[3, 1]); //OUTPUT: 7
Для создания многомерных массивов могут использоваться те же самые языковые конструкции, которые показаны выше для одномерных массивов. Возможно, что на первом этапе работы с массивами в C# сложность будет представлять перебор элементов многомерных массивов. На самом деле, ничего сложного в этом нет.
Основные методы и свойства для работы с массивами в C#
Для того, чтобы показать перебор элементов многомерных массивов, нам придётся забежать немного вперед и прояснить для себя один момент. В C# массивы представляют собой объекты со своими свойствами и методами. Если Вы имели дело с другими языками программирования, например, с Delphi, то знаете, что для получения, например, длины массива необходимо использовать отдельный метод — Length(). В C# же, в силу того, что массив — это объект, вы можете вызвать методы и читать свойства этого объекта просто написав его имя и нажав точку. В результате вы увидите вот такой список:
Подобная функциональность C# достаточно сильно упрощает изучение языка — нам не надо держать в голове перечень отдельных методов для работу с тем или иным типов данных, всё, что нам необходимо — это вызвать список методов и свойств объекта и выбрать необходимый. О том, как такое поведение осуществляется в C# мы обязательно обсудим в одной из статей блога, а пока я перечислю основные свойства и методы объектов-массивов в C#.
Свойства массивов C#
Название Тип данных Описание Length int Возвращает общее число элементов во всех измерениях массива Rank int Получает ранг (число измерений) массива Long Length long Возвращает 64-разрядное целое число, представляющее общее число элементов во всех измерениях массива Методы массивов в C#
Название Тип данных Описание Get Length() int Возвращает 32-разрядное целое число, представляющее количество элементов в заданном измерении массива Get Lower Bound() int Получает Индекс первого элемента заданного измерения в массиве Get Upper Bound() int Получает Индекс последнего элемента заданного измерения в массиве. Это далеко не все свойства и методы для работы с массивами в C#, но приводить их сейчас не имеет смысла, так как, во-первых, перечисленных свойств достаточно, чтобы понять как работать с массивами и, во-вторых, даже приведя перечень оставшихся свойств и методов, мы не сможем ими правильно воспользоваться, так как знаний у нас с вами пока не достаточно.
Перебор элементов многомерного массива C#
В цикле foreach
Цикл foreach предоставляет нам самый простой и понятный способ доступа к каждому элементы массива. Например, возьмем наш двумерный массив и попробуем перебрать все его элементы в цикле foreach:
int[,] array = new int[5, 2] < < 0, 1 >, < 2, 3 >, < 4, 5 >, < 6, 7 >, < 8, 9 >>; foreach (int i in array) < Console.Write("", i);; >В результате, в консоли появится строка, содержащая элементы массива:
0 1 2 3 4 5 6 7 8 9
Цикл foreach «разворачивает» массив в строку, наращивая вначале индексы самого правого измерения (в нашем случае, это измерение имеет длину 2 ), а затем смещается влево и перебирает все индексы этого измерения. Это очень простой способ добраться до всех элементов многомерного массива. Но, что делать, если нам необходимо пройти только по крайнему правому столбцу? То есть получить значения 1, 3, 5, 7, 9. Для этого мы можем воспользоваться циклом for .
В цикле for
Как я уже говорил выше, цикл for даёт более гибкий механизм работы с массивами C#. Итак, получим все значения элементов из последнего столбца. Приведу только два варианта. Вариант 1 — когда ранг массива известен и мы знаем размерность (количество элементов) последнего измерения:
for (int i=0; i ", array[i,1]);
здесь в условии цикла мы воспользовались методом GetLength() , чтобы получить количество элементов по первому измерению ( 5 ), а уже в теле цикла получаем значения элементов в каждой строке во втором столбце (помним, что индекс первых элементов в массиве всегда равен 0 ).
Второй вариант — нам надо прочитать значения в последнем столбце массива, но, при этом мы не знаем размерность второго измерения. Чтобы было по-понятнее, я объявил в коде две дополнительные переменные:
int rank = array.Rank-1; int maxIndex = array.GetUpperBound(0) + 1; for (int i=0; i ", array[i, array.GetUpperBound(rank)]);
В цикле мы запрашиваем элемент с индексами:
array[i, //текущая строка array.GetUpperBound(rank)]) //последний столбец
Соответственно, если необходимо пройти по всем элементам массива, то можно использовать вложенные циклы for и организовать доступ к элементам массива в любом порядке — построчно, по столбцам…да хоть по диагонали — тут всё будет зависеть от задачи.
Массивы массивов в C#
Массив массивов — это массив, элементы которого сами являются массивами. Элементы массива массивов могут иметь различные измерения и размеры. Массив массивов также иногда называется нерегулярным или зубчатым массивом. Объявление массива массивов выглядит следующим образом:
int[][] array = new int[3][];
здесь мы объявили массив массивов на три элемента где каждый элемент — это отдельный массив. Так как массивы в C# относятся к ссылочным типам данных, то по умолчанию каждый элемент массива равен null и, чтобы использовать элементы такого массива, нам необходимо их также инициализировать. Например, так:
array[0] = new int[2]; array[1] = new int[3]; array[2] = new int[4];
Теперь наш массив содержит три массива на 2, 3 и 4 элемента соответственно и каждый из этих массивов будет содержать целые числа. Чтобы заполнить массив значениями элементов, можно воспользоваться любым из способов, которые мы рассмотрели для одномерных массивов, например, так:
int[][] array = new int[][] < new int[] < 1, 2>, new int[] < 3, 4, 5 >, new int[] < 6, 7, 8, 9 >>;
Для доступа к элементам массива массивов необходимо использовать вот такую языковую конструкцию:
array[0][1] //2
Неявно типизированные массивы
Как и обычные переменные, C# допускает объявление неявно типизированных массивов. При этом, компилятор сам определить наиболее подходящий тип элементов такого массива. Например,
var a = new[] < 1, 10, 100, 1000 >; // int[] var b = new[] < "hello", null, "world" >; // string[]
При этом, если Вы попытаетесь объявить вот такой массив:
var с = new[] < 1, null, "world" >;
то компилятор C# вернет следующую ошибку:
Ошибка CS0826 Нет подходящего типа для неявно типизированного массива.
Работать с такими массивами можно точно также, как и со всеми другими типами массивов, которые были рассмотрены выше.
Получение элементов массива с конца
Начиная с версии C# 8.0, в язык был добавлен специальный оператор ^ , с помощью которого можно задать индекс относительно конца коллекции. Например,
int[] arr = [1, 2, 3, 4, 5]; int a = arr[^1]; //5. ПЕРВЫЙ элемент С КОНЦА int b = arr[^2]; //4. ВТОРОЙ элемент С КОНЦА
Итого
Итак, сегодня мы рассмотрели массивы в C# — для чего нужны массивы, какие бывают массивы, как получить доступ к элементам массива, а также их основные свойства и методы в C#. Возможно, что пока тяжело понять всю мощь и преимущества использования массивов в программировании, но, со временем всё встанет на свои места.
уважаемые посетители блога, если Вам понравилась, то, пожалуйста, помогите автору с лечением. Подробности тут.