Выбор между интерфейсом и абстрактным классом

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

Стандартные интерфейсы для среды .NET Framework

Для среды .NET Framework определено немало стандартных интерфейсов, которы­ми можно пользоваться в программах на С#. Так, в интерфейсе System.IComparable определен метод CompareTo(), применяемый для сравнения объектов, когда требу­ется соблюдать отношение порядка. Стандартные интерфейсы являются также важ­ной частью классов коллекций, предоставляющих различные средства, в том числе стеки и очереди, для хранения целых групп объектов. Так, в интерфейсе System.Collections.ICollection определяются функции для всей коллекции, а в интер­фейсе System.Collections.IEnumerator - способ последовательного обращения к элементам коллекции.

Структуры

Как вам должно быть уже известно, классы относятся к ссылочным типам данных. Это означает, что объекты конкретного класса доступны по ссылке, в отличие от значе­ний простых типов, доступных непосредственно. Но иногда прямой доступ к объектам как к значениям простых типов оказывается полезно иметь, например, ради повыше­ния эффективности программы. Ведь каждый доступ к объектам (даже самым мелким) по ссылке связан с дополнительными издержками на расход вычислительных ресурсов и оперативной памяти. Для разрешения подобных затруднений в С# предусмотрена структура, которая подобна классу, но относится к типу значения, а не к ссылочному типу данных.

Структуры объявляются с помощью ключевого слова struct и с точки зрения син­таксиса подобны классам. Ниже приведена общая форма объявления структуры:

struct имя : интерфейсы

{

// объявления членов

}

где имя обозначает конкретное имя структуры.

Одни структуры не могут наследовать другие структуры и классы или служить в качестве базовых для других структур и классов. (Разумеется, структуры, как и все остальные типы данных в С#, наследуют класс object.) Тем не менее в структуре мож­но реализовать один или несколько интерфейсов, которые указываются после имени структуры списком через запятую. Как и у классов, у каждой структуры имеются свои члены: методы, поля, индексаторы, свойства, операторные методы и события. В струк­турах допускается также определять конструкторы, но не деструкторы. В то же время для структуры нельзя определить конструктор, используемый по умолчанию (т.е. кон­структор без параметров). Дело в том, что конструктор, вызываемый по умолчанию, определяется для всех структур автоматически и не подлежит изменению. Такой кон­структор инициализирует поля структуры значениями, задаваемыми по умолчанию. А поскольку структуры не поддерживают наследование, то их члены нельзя указывать как abstract, virtual или protected.

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

В приведенном ниже примере программы демонстрируется применение структу­ры для хранения информации о книге.

Листинг 12.14

// Продемонстрировать применение структуры.

using System;

// Определить структуру.

struct Book

{

public string Author;

public string Title;

public int Copyright;

public Book(string a, string t, int c) {

Author = a;

Title = t;

Copyright = c;

}

}

// Продемонстрировать применение структуры Book.

class StructDemo

{

static void Main()

{

Book book1 = new Book("Герберт Шилдт",

"Полное руководство по C# 4.0",

2010); // вызов явно заданного конструктора

Book book2 = new Book(); // вызов конструктора по умолчанию

Book book3; // конструктор не вызывается

Console.WriteLine(book1.Title + " by " + book1.Author +

", (c) " + book1.Copyright);

Console.WriteLine();

if(book2.Title == null)

Console.WriteLine("Член book2.Title пуст.");

// А теперь ввести информацию в структуру book2.

book2.Title = "О дивный новый мир";

book2.Author = "Олдос Хаксли";

book2.Copyright = 1932;

Console.Write("Структура book2 теперь содержит: ");

Console.WriteLine(book2.Title + " by " + book2.Author +

", (c) " + book2.Copyright);

Console.WriteLine();

// Console.WriteLine(book3.Title); // ошибка, этот член структуры

// надо сначала инициализировать

book3.Title = "Красный шторм";

Console.WriteLine(book3.Title); // теперь правильно

}

}

При выполнении этой программы получается следующий результат.

Герберт Шилдт, Полное руководство по С# 4.0, (с) 2010

Член book2.Title пуст.

Структура book2 теперь содержит:

Олдос Хаксли, О дивный новый мир, (с) 1932

Красный шторм

Как демонстрирует приведенный выше пример программы, структура может быть инициализирована с помощью оператора new для вызова конструктора или же путем простого объявления объекта. Так, если используется оператор new, то поля структуры инициализируются конструктором, вызываемым по умолчанию (в этом случае во всех полях устанавливается задаваемое по умолчанию значение), или же конструктором, определяемым пользователем. А если оператор new не используется, как это имеет место для структуры bоок3, то объект структуры не инициализируется, а его поля должны быть установлены вручную перед тем, как пользоваться данным объектом.

Когда одна структура присваивается другой, создается копия ее объекта. В этом за­ключается одно из главных отличий структуры от класса. Как пояснялось ранее в этой книге, когда ссылка на один класс присваивается ссылке на другой класс, в итоге ссылка в левой части оператора присваивания указывает на тот же самый объект, что и ссылка в правой его части. А когда переменная одной структуры присваивается переменной другой структуры, создается копия объекта структуры из правой части оператора при­сваивания. Рассмотрим в качестве примера следующую программу.

Листинг 12.15

// Копировать структуру.

using System;

// Определить структуру.

struct MyStruct {

public int x;

}

// Продемонстрировать присваивание структуры.

class StructAssignment

{

static void Main()

{

MyStruct a;

MyStruct b;

a.x = 10;

b.x = 20;

Console.WriteLine("a.x {0}, b.x {1}", a.x, b.x);

a = b;

b.x = 30;

Console.WriteLine("a.x {0}, b.x {1}", a.x, b.x);

}

}

Вот к какому результату приводит выполнение этой программы.

а.х 10, b.x 20

a.x 20, b.x 30

Как показывает приведенный выше результат, после присваивания

а = b;

переменные структуры а и b по-прежнему остаются совершенно обособленными, т.е. переменная а не указывает на переменную b и никак не связана с ней, помимо того, что она содержит копию значения переменной b. Ситуация была бы совсем иной, если бы переменные а и b были ссылочного типа, указывая на объекты определенного клас­са. В качестве примера ниже приведен вариант предыдущей программы, где демон­стрируется присваивание переменных ссылки на объекты определенного класса.

Листинг 12.16

// Использовать ссылки на объекты определенного класса.

using System;

// Создать класс.

class MyClass {

public int x;

}

// Показать присваивание разных объектов данного класса.

class ClassAssignment

{

static void Main()

{

MyClass a = new MyClass();

MyClass b = new MyClass();

a.x = 10;

b.x = 20;

Console.WriteLine("a.x {0}, b.x {1}", a.x, b.x);

a = b;

b.x = 30;

Console.WriteLine("a.x {0}, b.x {1}", a.x, b.x);

}

}

Выполнение этой программы приводит к следующему результату.

а.х 10, b.x 20

a.x 30, b.x 30

Как видите, после того как переменная b будет присвоена переменной а, обе пере­менные станут указывать на один и тот же объект, т.е. на тот объект, на который перво­начально указывала переменная b.

О назначении структур

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

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

Листинг 12.17

// Структуры удобны для группирования небольших объемов данных.

using System;

// Определить структуру пакета.

struct PacketHeader

{

public uint PackNum; // номер пакета

public ushort PackLen; // длина пакета

}

// Использовать структуру PacketHeader для создания

// записи транзакции в сфере электронной коммерции.

class Transaction

{

static uint transacNum = 0;

PacketHeader ph; // ввести структуру PacketHeader

// в класс Transaction

string accountNum;

double amount;

public Transaction(string acc, double val) {

// создать заголовок пакета

ph.PackNum = transacNum++;

ph.PackLen = 512; // произвольная длина

accountNum = acc;

amount = val;

}

// Сымитировать транзакцию.

public void sendTransaction()

{

Console.WriteLine("Пакет #: " + ph.PackNum +

", Длина: " + ph.PackLen +

",\n Счет #: " + accountNum +

", Сумма: {0:C}\n", amount);

}

}

// Продемонстрировать применение структуры в виде пакета транзакции

class PacketDemo

{

static void Main()

{

Transaction t = new Transaction("31243", -100.12);

Transaction t2 = new Transaction("AB4655", 345.25);

Transaction t3 = new Transaction("8475-09", 9800.00);

t.sendTransaction();

t2.sendTransaction();

t3.sendTransaction();

}

}

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

Пакет #: 0, Длина: 512,

Счет #: 31243, Сумма: $100.12

Пакет #: 1, Длина: 512,

Счет #: AB4655, Сумма: $345.25

Пакет #: 2, Длина: 512,

Счет #: 8475-09, Сумма: $9,800.12

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

Любопытно, что в С++ также имеются структуры и используется ключевое слово struct. Но эти структуры отличаются от тех, что имеются в С#. Так, в С++ структура относится к типу класса, а значит, структура и класс в этом языке практически равно­ценны и отличаются друг от друга лишь доступом по умолчанию к их членам, которые оказываются закрытыми для класса и открытыми для структуры. А в С# структура от­носится к типу значения, тогда как класс - к ссылочному типу.

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

Перечисление представляет собой множество именованных целочисленных констант. Перечислимый тип данных объявляется с помощью ключевого слова enum. Ниже при­ведена общая форма объявления перечисления:

enum имя { список_перечисления} ;

где имя - это имя типа перечисления, а список_перечисления - список идентифи­каторов, разделяемый запятыми.

В приведенном ниже примере объявляется перечисление Apple различных сортов яблок.

enum Apple { Jonathan, GoldenDel, RedDel, Winesap,

Cortland, Mcintosh };

Следует особо подчеркнуть, что каждая символически обозначаемая константа в перечислении имеет целое значение. Тем не менее неявные преобразования пере­числимого типа во встроенные целочисленные типы и обратно в С# не определены, а значит, в подобных случаях требуется явное приведение типов. Кроме того, приве­дение типов требуется при преобразовании двух перечислимых типов. Но поскольку перечисления обозначают целые значения, то их можно, например, использовать для управления оператором выбора switch или же оператором цикла for.

Для каждой последующей символически обозначаемой константы в перечислении задается целое значение, которое на единицу больше, чем у предыдущей константы. По умолчанию значение первой символически обозначаемой константы в перечисле­нии равно нулю. Следовательно, в приведенном выше примере перечисления Apple константа Jonathan равна нулю, константа GoldenDel - 1, константа RedDel - 2 и т.д.

Доступ к членам перечисления осуществляется по имени их типа, после которого следует оператор-точка. Например, при выполнении фрагмента кода

Console.WriteLine(Apple.RedDel + " имеет значение " +

(int)Apple.RedDel) ;

выводится следующий результат.

RedDel имеет значение 2

Как показывает результат выполнения приведенного выше фрагмента кода, для вы­вода перечислимого значения используется его имя. Но для получения этого значения требуется предварительно привести его к типу int.

Ниже приведен пример программы, демонстрирующий применение перечисле­ния Apple.

Листинг 12.18

// Продемонстрировать применение перечисления.

using System;

class EnumDemo {

enum Apple { Jonathan, GoldenDel, RedDel, Winesap,

Cortland, McIntosh };

static void Main() {

string[] color = {

"красный",

"желтый",

"красный",

"красный ",

"красный ",

"красновато-зеленый"

};

Apple i; // объявить переменную перечислимого типа

// Использовать переменную i для циклического

// обращения к членам перечисления.

for(i = Apple.Jonathan; i <= Apple.McIntosh; i++)

Console.WriteLine(i + " имеет значение " + (int)i);

Console.WriteLine();

// Использовать перечисление для индексирования массива.

for(i = Apple.Jonathan; i <= Apple.McIntosh; i++)

Console.WriteLine("Цвет сорта " + i + " is " +

color[(int)i]);

}

}

Ниже приведен результат выполнения этой программы.

Jonathan имеет значение 0

GoldenDel имеет значение 1

RedDel имеет значение 2

Winsap имеет- значение 3

Cortland имеет значение 4

Mcintosh имеет значение 5

Цвет сорта Jonathan - красный

Цвет сорта GoldenDel - желтый

Цвет сорта RedDel - красный

Цвет сорта Winsap - красный

Цвет сорта Cortland - красный

Цвет сорта Mcintosh - красновато-зеленый

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

И еще одно замечание: все перечисления неявно наследуют от класса System.Enum, который наследует от класса System.ValueType, а тот, в свою очередь, - от класса object.