Эндрю Троелсен - ЯЗЫК ПРОГРАММИРОВАНИЯ С# 2005 И ПЛАТФОРМА .NET 2.0. 3-е издание
myShapes[2] = new Hexagon();
// Движение по массиву и отображение элементов.
foreach (Shape s in myShapes) s.Draw();
Console.ReadLine();
}
На этом наш краткий (и упрощенный) обзор принципов ООП завершается. Теперь, имея в запасе теорию, мы исследуем некоторые подробности и точный синтаксис C#, с помощью которого реализуются каждый из указанных принципов.
Первый принцип: сервис инкапсуляции C#
Понятие инкапсуляции отражает общее правило, согласно которому поля данных объекта не должны быть непосредственно доступны из открытого интерфейса. Если пользователь объекта желает изменить состояние объекта, то он должен делать это косвенно, с помощью методов чтения (get) и модификации (set). В C# инкапсуляция "навязывается" на уровне синтаксиса с помощью ключевых слов public, private, protected и protected internal, как было показано в главе 3. Чтобы проиллюстрировать необходимость инкапсуляции, предположим, что у нас есть следующее определение класса.
// Класс с одним общедоступным полем.
public class Book {
public int numberOfPages;
}
Проблема общедоступных полей данных заключается в том, что такие элементы не имеют никакой возможности "понять", является ли их текущее значение действительным с точки зрения "бизнес-правил" данной системы. Вы знаете, что верхняя граница диапазона допустимых значений для int в C# очень велика (она равна 2147483647). Поэтому компилятор не запрещает следующий вариант присваивания.
// М-м-м-да…
static void Main(stting[] args) {
Book miniNovel = new Book();
miniNovel.numberOfPages = 30000000;
}
Здесь нет перехода за границы допустимости для данных целочисленного типа, но должно быть ясно, что miniNovel ("мини-роман") со значением 30000000 для numberOfPages (число страниц) является просто невероятным с практической точки зрения. Как видите, открытые поля не обеспечивают проверку адекватности данных. Если система предполагает правило, по которому мини-роман должен содержать от 1 до 200 страниц, будет трудно реализовать это правило программными средствами. В этой связи открытые поля обычно не находят места на уровне определений классов, применяемых для решения реальных задач (исключением являются открытые поля, доступные только для чтения).
Инкапсуляция обеспечивает возможность сохранения целостности данных для состояния объекта. Вместо определения открытых полей (с помощью которых очень просто прийти к нарушению целостности данных), вашей привычкой должно стать определение частных полей данных, которые обрабатываются вызывающей стороной косвенно, с использованием одного из двух главных подходов.
• Определение пары традиционных методов чтения и модификации данных.
• Определение именованного свойства.
Суть любого их этих подходов заключается в том, что хорошо инкапсулированный класс должен скрыть от "любопытных глаз внешнего мира" необработанные данные и детали того, как выполняются соответствующие действия. Часто такой подход называют программированием "черного ящика". Красота этого подхода в том, что создатель класса имеет возможность изменить особенности реализации любого из своих методов, так сказать, "за кулисами", и нет никакой нужды отменять использование уже существующего программного кода (при условии, что имя метода остается прежним).
Инкапсуляция на основе методов чтения и модификации
Давайте снова вернемся к рассмотрению нашего класса Employee. Чтобы "внешний мир" мог взаимодействовать с частным полем данных fullName, традиции велят определить средства чтения (метод get) и модификации (метод set). Например:
// Традиционные средства чтения и модификации для приватных данных.
public class Employee {
private string fullName;
…
// Чтение.
public string GetFullName() {return fullName;}
// Модификация.
public void SetFullName(string n) {
// Удаление недопустимых символов (!, @, #, $, %),
// проверка максимальной длины (или регистра символов)
// перед присваиванием.
fullName = n;
}
}
Конечно, компилятору "все равно", что вы будете вызывать методы чтения и модификации данных. Поскольку GetFullName() и SetFullName() инкапсулируют приватную строку с именем fullName, выбор таких имен кажется вполне подходящим. Логина вызова может быть следующей.
// Использование средств чтения/модификации.
static void Main(string[] args) {
Employee p = new Employee();
p.SetFullName("Фред Флинстон");
Console.WriteLine("Имя работника: {0} ", p.GetFullName());
Console.ReadLine();
}
Инкапсуляция на основе свойств класса
В отличие от традиционных методов чтения и модификации, языки .NET тяготеют к реализации принципа инкапсуляции на основе использования свойств, которые представляют доступные для внешнего пользователя элементы данных. Вместо того, чтобы вызывать два разных метода (get и set) для чтения и установки данных состояния объекта, пользователь получает возможность вызвать нечто, похожее на общедоступное поле. Предположим, что мы имеем свойство с именем ID (код), представляющее внутренний член-переменную empID типа Employee. Синтаксис вызова в данном случае должен выглядеть примерно так.
// Синтаксис установки/чтения значения ID работника.
static void Main(string[] args) {
Employee p = new Employee();
// Установка значения.
p.ID = 81;
// Чтение значения.
Console.WriteLine ("ID работника: {0} ", p.ID); Console.ReadLine();
}
Свойства типа "за кадром" всегда отображаются в "настоящие" методы чтения и модификации. Поэтому, как разработчик класса, вы имеете возможность реализовать любую внутреннюю логику, выполняемую перед присваиванием соответствующего значения (например, перевод символов в верхний регистр, очистку значения от недопустимых символов, проверку принадлежности числового значения диапазону допустимости и т.д.). Ниже демонстрируется синтаксис C#. использующий, кроме свойства ID, свойство Pay (оплата), которое инкапсулирует поле currPay, a также свойство Name (имя), которое инкапсулирует данные fullName.
// Инкапсуляция с помощью свойств.
public class Employee {
...
private int empID;
private float currPay;
private string fullName;
// Свойство для empID.
public int ID {
get {return empID;}
set {
// Вы можете проверить и, если требуется, модифицировать
// поступившее значение перед присваиванием.
empID = value;
}
}
// Свойство для fullName.
public string Name {
get { return fullName; }
set { fullName = value; }
}
// Свойство для currPay.
public float Pay {
get { return currPay; }
set { currPay = value; }
}
}
Свойство в C# компонуется из блока чтения и блока модификации (установки) значении. Ярлык value в C# представляет правую сторону оператора присваивания. Соответствующий ярлыку value тип данных зависит от того, какого сорта данные этот ярлык представляет. В данном примере свойство ID оперирует с типом данных int, который, как вы знаете, отображается в System.Int32.
// 81 принадлежит System.Int32,
// поэтому "значением" является System.Int32.
Employee e = new Employee();
e.ID = 81;
Чтобы это доказать, предположим, что вы добавили следующий программный код для установки свойства ID.
// Свойство для empID.
public int ID {
get {return empID;}
set {
Console.WriteLine("value является экземпляром {0} ", value.GetType());
Console.WriteLine("Значение value: {0} ", value); empID = value;
}
}
Выполнив приложение, вы должны увидеть вариант вывода, показанный на рис. 4.5.
Рис. 4.5. Значение value после установки для ID значения 81
Замечание. Строго говоря, ярлык value в C# является не ключевым оловом, а, скорее, контекстным ключевым словом, представляющим неявный параметр, который используется в операторе присваивания в контексте метода, используемого для установки значения свойства. Поэтому вполне допустимо иметь члены-переменные и локальные элементы данных с именем value.
