1) Одномерные и многомерные числовые массивы:

Массивом называют упорядоченную совокупность элементов одного типа. Каждый элемент массива имеет индексы, определяющие порядок элементов. Индексы задаются целочисленным типом. Число индексов характеризует размерность массива. Если конечное значение задано константным выражением, то число элементов массива известно в момент его объявления и ему может быть выделена память ещё на этапе трансляции. Такие массивы называются статическими. Если же конечное значение зависят от переменной, то такой массив называют динамическим, поскольку память ему может быть отведена только динамически в процессе выполнения программы, когда становятся известными значения соответствующих переменных. Массиву, как правило, выделяется непрерывная область памяти.

В языке C# каждый индекс изменяется в диапазоне от 0 до некоторого конечного значения. Массивы в языке C# являются настоящими динамическими массивами. Как следствие этого, массивы относятся к ссылочным типам, память им отводится динамически в "куче". Массивы могут быть одномерными и многомерными.

Объявление одномерного массива выглядит следующим образом:

<тип>[] <объявители>;

Как и в случае объявления простых переменных, каждый объявитель может быть именем или именем с инициализацией. В первом случае речь идёт об отложенной инициализации. Нужно понимать, что при объявлении с отложенной инициализацией сам массив не формируется, а создаётся только ссылка на массив, имеющая неопределённое значение Null. Поэтому пока массив не будет реально создан и его элементы инициализированы, использовать его в вычислениях нельзя!!! Вот пример объявления трёх массивов с отложенной инициализацией:

int[] a, b, c;

Чаще всего при объявлении массива используется имя с инициализацией. И опять-таки, как и в случае простых переменных, могут быть два варианта инициализации. В первом случае инициализация является явной и задаётся константным массивом. Вот пример:

double[] x = {5.5, 6.6, 7.7};

Следуя синтаксису, элементы константного массива следует заключать в фигурные скобки. Если массив инициализируется константным массивом, то в динамической памяти создаётся константный массив с заданными значениями, с которым и связывается ссылка.

Во втором случае создание массива выполняется с помощью операции new. Вот пример:

int[] d = new int[5];

Здесь объявлен динамический целочисленный массив, в котором будут храниться 5 целых чисел. Массив создаётся в динамической памяти, его элементы получают начальные нулевые значения, и ссылка связывается с этим массивом.

Как обычно задаются элементы массива, если они не заданы при инициализации? Они либо вычисляются, либо вводятся пользователем. Рассмотрим пример работы с массивами:

// объявляются три одномерных массива A,B,C
int[] A = new int[5], B= new int[5], C= new int[5];
// заполняется данными с клавиатуры массив A
for(int i = 0; i < 5; i++) A[i] = int.Parse(Console.ReadLine());
// вычисляются элементы массива C
for(int i = 0; i < 5; i++) C[i] = A[i] + B[i];
// объявление массива с явной инициализацией
int[] x ={5.5, 6.6, 7.7};
// объявление массивов с отложенной инициализацией
int[] u, v;
u = new int[3];
for(int i = 0; i < 3; i++) u[i] = i + 1;
// v = {1,2,3}; // присваивание константного массива недопустимо!
v = new int[4];	
v = u; // допустимое присваивание – массивы одного класса
int [,] w = new int[3,5];
// v = w; // недопустимое присваивание: объекты разных классов

На что следует обратить внимание, анализируя этот текст:

• Показаны разные способы объявления массивов. В начале объявляются одномерные массивы A, B и C. Значения элементов этих трёх массивов имеют один и тот же тип int. То, что они имеют одинаковое число элементов, произошло по воле программиста, а не диктовалось требованиями языка. Значения в массив А вводились, а в массив B - нет, но сложение элементов корректно, потому что при объявлении элементы массива B получили нулевые значения.
• Массив x объявлен с явной инициализацией. Число и значения его элементов определяется константным массивом.
• Массивы u и v объявлены с отложенной инициализацией. В последующих операторах массив u инициализируется в объектном стиле – его элементы получают значения в цикле.
• Обратите внимание на закомментированный оператор присваивания! В отличие от инициализации, использовать константный массив в правой части оператора присваивания недопустимо. Эта попытка приводит к ошибке, поскольку v - это ссылка, и ей нельзя присвоить константный массив. А вот ссылку присвоить можно. Что происходит в операторе присваивания v = u? Это корректное ссылочное присваивание: хотя u и v имеют разное число элементов, но они являются объектами одного класса – оба массива целочисленные. В результате присваивания память, отведённая массиву v, освободится, ею займется теперь сборщик мусора. Обе ссылки u и v будут теперь указывать на один и тот же массив, так что изменение элемента одного массива немедленно отразится на другом массиве. Имена u и v становятся синонимами (или псевдонимами друг друга…).
• Далее определяется двумерный массив w и делается попытка выполнить оператор присваивания v = w. Это ссылочное присваивание некорректно, поскольку объекты w и v - разных классов (разноразмерные массивы) и для них не выполняется требуемое для присваивания согласование по типу.

В вышеприведённых примерах объявлялись статические массивы, поскольку нижняя граница равна нулю по определению, а верхняя всегда задавалась в этих примерах константой. Вспомним, что в C# все массивы, независимо от того, каким выражением описывается граница, рассматриваются как динамические, и память для них распределяется в "куче". Чисто синтаксически нет существенной разницы в объявлении статических и динамических массивов. Выражение, задающее границу изменения индексов, в динамическом случае содержит переменные. Единственное требование – значения переменных должны быть определены в момент объявления! Это ограничение в C# выполняется автоматически, поскольку хорошо известно, насколько требовательно C# контролирует инициализацию переменных. Рассмотрим пример:

// объявление динамического массива A1
Console.WriteLine("Введите число элементов массива A1");
int size = int.Parse(Console.ReadLine());
int[] A1 = new int[size];

В особых комментариях эта процедура не нуждается. Здесь верхняя граница массива определяется пользователем.

Теперь можно рассмотреть особый вид оператора цикла – оператор foreach. Его синтаксис:

foreach(тип идентификатор in массив) оператор

Цикл работает в полном соответствии со своим названием – тело цикла выполняется для каждого элемента в контейнере. Тип идентификатора должен быть согласован с типом элементов, хранящихся в массиве данных. Предполагается также, что элементы массива упорядочены. На каждом шаге цикла идентификатор, задающий текущий элемент массива, получает значение очередного элемента в соответствии с порядком, установленным на элементах массива. С этим текущим элементом и выполняется тело цикла - выполняется столько раз, сколько элементов находится в массиве. Цикл заканчивается, когда полностью перебраны все элементы массива.

В приведённом ниже примере показана работа с трёхмерным массивом. Массив создаётся с использованием циклов типа for, а при нахождении суммы его элементов, минимального и максимального значения используется цикл foreach:

int [,,] arr3d = new int[10, 10, 10];
for(int i = 0; i < 10; i++)
   for(int j = 0; j < 10; j++)
      for(int k = 0; k < 10; k++)
         arr3d[i, j, k] = int.Parse(Console.ReadLine());
long sum = 0;
int min = arr3d[0, 0, 0], max = arr3d[0, 0, 0];
foreach(int item in arr3d)
{
   sum += item;
   if(item > max) max = item;
   else if (item < min) min = item;
}
Console.WriteLine("sum = {0}, min = {1}, max = {2}", 
                     sum, min, max);

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

Поговорим теперь о многомерных массивах. Я уже показывал в примерах, что они задаются следующей формой:

<тип>[, ... ,] <объявители>;

Число запятых, увеличенное на единицу, и задаёт размерность массива. Что касается объявителей, то всё, что сказано для одномерных массивов, справедливо и для многомерных. Можно лишь отметить, что хотя явная инициализация с использованием многомерных константных массивов возможна, но применяется редко из-за громоздкости такой структуры. Проще инициализацию реализовать программно, но иногда она всё же применяется. Вот пример:

int[,] matrix = {{1,2},{3,4}};

2) Класс Array:

Нельзя понять многие детали работы с массивами в C#, если не знать устройство класса Array из библиотеки FCL, потомками которого по определению являются все классы-массивы. Рассмотрим следующие объявления:

int[] ar1 = new int[5];
double[] ar2 = {5.5, 6.6, 7.7};
int[,] ar3 = new Int32[3,4];

Зададимся естественным вопросом: к какому типу, или к каким классам принадлежат объекты ar1, ar2 и ar3? Ответ прост: все они принадлежат к разным классам. Переменная ar1 принадлежит к классу int[] – одномерному массиву значений типа int, ar2 – double[], одномерному массиву значений типа double, ar3 – двумерному массиву значений типа int. Следующий закономерный вопрос: а что общего есть у этих трёх объектов? Прежде всего, все три класса этих объектов, как и другие классы, являются потомками класса Object, а потому имеют общие методы, наследованные от класса Object и доступные объектам этих классов.

У всех классов, являющихся массивами, много общего, поскольку все они являются потомками класса System.Array. Класс System.Array наследует ряд интерфейсов: ICloneable, IList, ICollection, IEnumerable, а, следовательно, обязан реализовать все их методы и свойства. Помимо наследования свойств и методов класса Object и вышеперечисленных интерфейсов, класс Array имеет довольно большое число собственных методов и свойств. Взгляните, как выглядит отношение наследования на семействе классов, определяющих массивы.

Благодаря такому мощному родителю, над массивами определены самые разнообразные операции – копирование, поиск, обращение, сортировка, получение различных характеристик. Статические методы класса Array позволяют решать самые разнообразные задачи:

1. Copy – позволяет копировать весь массив или его часть в другой массив.
2. IndexOf, LastIndexOf – определяют индексы первого и последнего вхождения образца в массив, возвращая значение -1, если такового вхождения не обнаружено.
3. Reverse – выполняет обращение массива, переставляя элементы в обратном порядке.
4. Sort – осуществляет сортировку массива.
5. BinarySearch – определяет индекс первого вхождения образца в отсортированный массив, используя алгоритм двоичного поиска.