Работа с массивами.

Массивы - это механизм объединения отдельных элементов в набор, рассматриваемый как единое целое. Общеязыковая исполняющая среда Microsoft.NET (CLR) поддерживает массивы одномерные (single-dimension), многомерные (multidimension) и вложенные (jagged). Базовым для всех массивов является тип System.Аггау, производный от System.Object. А это значит, что массивы всегда относятся к ссылочному типу и размещаются в управляемой куче, а переменная в приложении содержит не сам массив, а ссылку на него.

Формальное определение массива выглядит так: массив - это набор элементов, доступ к которым производится с помощью числового индекса. Массивы могут содержать элементы любого встроенного типа данных С#, в том числе могут существовать массивы объектов, интерфейсов и структур.

Для объявления одномерного массива используется следующая форма записи.

тип[ ] имя_массива = new тип [размер];

Здесь тип - это базовый тип массива. Базовый тип определяет тип данных каждого элемента, составляющего массив. Одна пара квадратных скобок за элементом записи тип означает, что определяется одномерный массив. Количество элементов, которые будут храниться в массиве, определяется элементом размер. В С# число элементов массива задают при создании массива. Таким образом, верхняя граница массива всегда на единицу меньше числа его элементов.

Поскольку массивы реализуются как объекты, их создание представляет собой двухступенчатый процесс. Сначала объявляется ссылочная переменная на массив, а затем для него выделяется память, и переменной массива присваивается ссылка на эту область памяти. Таким образом, в С# массивы динамически размещаются в памяти с помощью оператора new.

Пример:

Int32[] myIntegers = new Int32[10];// Создаем массив из 10 элементов типа Int32.

Объявлять и инициализировать массивы можно в два этапа. В одной строке разрешается объявить массив, а в другой - динамически инициализировать его, как показано ниже:

Int32[] mуIntegers; // Объявляем ссылку на массив.

myIntegers = new Int32[10]; // Создаем массив из 10 элементов типа Int32.

В первой строке объявляется переменная myIntegers для хранения ссылки на одномерный массив элементов типа Int32. Вначале myIntegers присваивается null, так как память под массив пока не выделена. Во второй строке выделяется память под 10 значений типа Int32; все они инициализируются 0. Хотя Int32 относится к размерным типам, необходимая для хранения этих значений память выделяется в управляемой куче. Блок памяти содержит 10 значений Int32. Возвращенный адрес этого блока памяти заносится в переменную myIntegers.

Аналогично создается и массив элементов ссылочного типа:

Control[] myControls; // Объявляем ссылку на массив.

myControls = new Control[4]; // Создаем массив из 4 ссылок на Control.

В первой строке объявлена переменная myControls для размещения ссылки на одномерный массив ссылок на элементы Control. Вначале myControls присваивается null, ведь память под массив не выделена. Во второй строке выделяется память под 4ссылки на Control; всем этим ссылкам присваивается null. Поскольку Control относится к ссылочным типам, то создание массива сводится только к созданию пустых (null) ссылок; реальные объекты в этот момент не создаются. Возвращенный адрес блока памяти заносится в переменную myControls. Чтобы заполнить массив реальными объектами, следует записать в каждый элемент массива ссылку на новый или существующий объект данного типа:

myControls[1] = new Bntton();

myControls[2] = new TextBox();

myControls[3] = myControls[2]; // Два элемента ссылаются на один и тот же объект

Массивы размерного и ссылочного типов в управляемой куче выглядят следующим образом:

В каждом массиве есть некоторая дополнительная информация (overhead). Это сведения о размерности массива (числе измерений), его нижней границе (чаще всего 0) и числе элементов в каждом измерении. Здесь же указан тип элементов массива.

Как и во многих других языках, в С# можно производить заполнение массива с помощью числовых индексов.

Т.е. с помощью десяти отдельных инструкций присваивания можно заполнить массив myIntegers.

mylntegers[0] = 123;

mylntegers[l] = 13;

mylntegers[2] = 23;

mylntegers[3] = 3; …

Существует более простой путь достижения той же цели: массивы можно инициализировать в момент их создания. Формат инициализации одномерного массива имеет следующий вид:

тип [] имя_массива = {val1, val2,..., valN};

Здесь начальные значения, присваиваемые элементам массива, задаются с помощью последовательности val1-valN. Значения присваиваются слева направо, в порядке возрастания индекса элементов массива. В этом случае нет необходимости использовать в явном виде оператор new.

Int32[] myIntegers= {2,3,4,1,2,3,4,5,7,8};

Хотя, как уже было отмечено выше, в этом нет необходимости, при инициализации массива все же можно использовать оператор new.

Int32[] myIntegers= new lnt32[] {2,3,4,1,2,3,4,5,7,8};

Несмотря на избыточность new-форма инициализации массива оказывается полезной в том случае, когда уже существующей ссылочной переменной массива присваивается новый массив.

Int32[] myIntegers;

myIntegers= new Int32[] {2,3,4,1,2,3,4,5,7,8};

Здесь массив myIntegers объявляется в первой инструкции и инициализируется во второй.

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

Пример.