Перечисления (enum)

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

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

const int left_align = 0; //Выравнивание по левому краю
const int right_align = 1; //Выравнивание по правому краю
const int center_aling = 2; //Выравнивание по центру

Т.е. нам, нужно было бы вести ряд отдельных констант, следить за корректностью назначения их значений (чтобы они не повторялись), объявлять их в одном участке кода (это конечно не обязательно, но желательно для упрощения поддержки кода) и т.д. В общем, вести ряд «служебной» работы… Избавить нас от этого могут перечисления. Давайте посмотрим как бы выглядело решение задачи, с использованием перечислений:

//Перечисление типов выравнивания
enum Align
{
    Left, //По левому краю
    Right, //По правому краю
    Center //По центру
}

Т.е. мы сгруппировали все три типа выравнивания в одну группу, в одно перечисление, дали ему логичное название Aling и получили тот же результат что и в первом случае. Создается новое перечисление по следующим правилам. Сначала следует ключевое слово enum, после него, через пробел, указывается имя перечисления, а после него, в фигурных скобках, список значений, через запятую (после последнего значения, запятую можно не ставить, но можно и поставить).

Обратите внимание, что при использовании перечисления, мы получили фактически тот же результат что и при использовании констант в примере, рассмотренном до этого. Дело в том, что перечисления, изначально создаются на основе типа int, и каждому значению, автоматически присваивается значение типа int, начиная с нулевого, каждому следующему добавляя единицу.

Посмотрите, как «выглядит» приведенное выше перечисление «изнутри»:

//Перечисление типов выравнивания
enum Align //На основе типа int
{
    Left, // = 0
    Right, // = 1
    Center // = 2
}

Но в основе лежащий тип, и конкретные значения элементам перечисления, можно задавать вручную, например, можно создать то же перечисление, но на основе типа long и с другими значениями:

//Перечисление типов выравнивания
enum Align : long //На основе типа long
{
    Left = 10, // = 10
    Right,     // = 11
    Center     // = 12
}

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

//Перечисление типов выравнивания
enum Align : long //На основе типа long
{
    Left,       // = 0
    Right = 20, // = 20
    Center      // = 21
}

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

Align.Center;

Более того, можно создать какую-то переменную, хранящую это значение:

Align center = Align.Center; 

А теперь посмотри, как можно применять вычисления на практике:

//Текущее выравнивание
Align currentAlign = Align.Left;

/*
* Представим, что тут пользователь 
* каким-то образом задал новое значение
*/

//А теперь мы обрабатываем указанное значение
switch (currentAlign)
{
    //Если нужно выравнивать по левому краю
    case Align.Left:
        //Выравниваем текст по левому краю
    break;

    //Если нужно выравнивать по правому краю
    case Align.Right:
        //Выравниваем текст по правому краю
    break;

    //Если нужно выравнивать по центру
    case Align.Center:
        //Выравниваем текст по центру
    break;
}

Вот так вот можно использовать перечисления в C# на практике!