Урок по C# №11: «Перечисления и многомерные массивы»

Этот урок завершает первую часть изучения C#. Вы должны уже знать базовый синтаксис языка и основные конструкции, чтобы изучать следующий уровень. Я сознательно разбил серию уроков по C# на несколько частей, стремясь идти от простейшего к сложному.

В следующей части мы изучим с вами ООП и приступим к разработке Windows приложений. Там уже будет все значительно интереснее, что скажется на понимании изложенного материала.  Мы также изучим с вами программирование для интернета, базы данных, игрописание с XNA и в качестве бонуса я научу вас писать торговых роботов для фондовых рынков.  Думаю, план вам понятен.

Итак, наберите воздуха в грудь и быстренько пробежите глазами по этому уроку. Уверяю, ничего сложно в нем нет. Он просто содержит те части материала, которые я логически не смог втиснуть в предыдущие уроки. После этого урока я рекомендую вам пройти небольшой практикум по языку C#.

Перечисления

Помните, я рассказывал вам о константах? Они хранят постоянное значение в программе все время ее выполнения. Однако в мало-мальски сложных программах (а это почти все, что отлично от «Hello World!») часто возникает потребность в неком наборе таких констант. Причем, желательно, чтобы они были логически объединены в некую структуру данных с одним именем. Вспомните массивы. Ведь как удобно было обращаться к элементу массива по его индексу.

В C# есть подобная структура и называется она перечисления (enum) . Давайте теперь рассмотрим, для чего нужны эти самые перечисления. Аналогию я буду проводить с .Netовской библиотекой.

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

Конечно, нагляднее привести пример с обычными приложениями Windows, ноя решил оставить их на вторую часть. В конце-концов, использование библиотечных контролов просто до безобразия.

Итак, вернемся к нашей задаче о программе, в которой нужно будет поменять цвет (шрифт, фон и т.д.). Наверняка вы хотели бы несколько упростить задачу пользователю. Например, как известно, цвет задается значениями красного, зеленого и синего цветов. Причем, шкала цвета идет от 0 до 255. Сказать по правде, лично я не могу подобрать  по этим комбинациям нужный мне цвет. Мне даже пришлось написать небольшую программку, которая выводит числовое значение выбранного на экране цвета. 🙂

Поэтому мы можем создать константы с нужным цветом и выбирать уже из них. Например, создать константу Green и задать ей шестнадцатиричное  значение цвета (от 1 до 255).  Таким же образом можно создать константы Blue, Yellow, Red. Purple и т.д. В принципе, с поставленной задачей мы бы справились подобным образом. Однако не кажется ли вам, что гораздо удобнее было бы засунть эти константы в некое множество, из которого можно было бы выбирать нужный нам цвет (или что-то, что взбредет нам в голову). C# позволяет нам это сделать, используя специальную структуру под названием перечисления (enum). Программистам С и С++ перечисления знакомы. В Паскале тоже есть перечисления, только там они называются наборы. В любом случае, сымсл тот же самый.

К сожалению, я выбрал не совсем удачный пример с цветом, так как дотнетовские библиотеки уже включат в себя  перечисления цвета. Например, свойство объекта Console BackgroundColor принимает значение из перечисления ConsoleColor. И таких примеров можно привести массу.

Тем не менее, нам важно научиться создавать свои перечисления. Давайте создадим перечисление цвета. Синтаксис перечисления такой:

enum  Имя_перечисления  {значение 1,значение 2 и т.д.};

Важно понимать, что значение перечисления можно задавать при объявлении (хотя и не обязательно). Например, давайте создадим перечисление ConsColor, в котором одному из значений зададим код цвета:

enum ConsColor

{ Red,

Green=120,

Blue,

Yellow,

Purple

};

Как видите, я задал явно 120 значению Green. Теперь C# будет считать, что этому значению соответствует 120. В остальных же случаях будут просто строковые константы.

Думаю,  что с этим вы разобрались. Более подробно о применении перечислений я расскажу в других уроках.

Для того, чтобы использовать перечисление, нужно объявить переменную его типа:

ConsColor color;

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

color.Red;

Внимательный читатель  может провести аналогию с классами и структурами – мы тоже обращались там к полям через точку. И те, и другие – типы данных, определяемые программистом самостоятельно. Перечисления тоже создаются самостоятельно и поэтому также относятся к типам данных, определяемых пользователем.

Если вы не совсем поняли о перечислениях, то советую почитать мой урок по C++ (дело в том, что там я писал все гораздо более развернуто, так как тот курс был расчитан на моего напарника-ученика, поэтому я часто ссылаюсь на него). Пока с перечислениями все.

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

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

К примеру, это двумерный массив 3х2. Подобных примеров множество. Например, в математике часто приходится иметь дело с матрицами, которые представляют собой типичный двумерный массив (он двумерный просто потому, что имеет его измерения строка и столбец).

Объявляется многомерный массив так:

тип_массива [,] имя массива=new тип_массива [размер,размер]; //это двумерный массив

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

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

Ну и так далее. Обращаться к элементам многомерного массива нужно указывая сначала номер строки (это первый размер), а потом уже номер столбца:

Arr [2,5]=25; //присвоили пятому элементу второй строки массива значение 25.

Если вам не понятно, вспомните школьную арифметику. Вы искали там в таблице умножения по перекрестью нужных чисел. Здесь принцип тот же самый. Давайте в качестве закрепления материала напишем программу, которая заполняет двумерный массив числами из таблицы умножения:

int[,] table = new int[9, 9]; //создали массив 9 на 9

for (int i=0; i<9;i++)
for (int j = 0; j < 9; j++) //обходим столбцы

{

table[i, j] = i * j; //перемножаем индексы

}

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

В принципе, на этом можно считать элементарную часть по C# оконченной. В следующем занятии вы выполните небольшой практикум, а потом уже приступим к изучению ООП в C#.

<< Предыдущий урок                                      Следующий урок>>