// Manager – это System.Object.
object frank = new Manager("Frank Zappa", 9, 40000, "111-11-1111", 5);
В системе Employees типы Manager, Salesperson и PTSalesPerson расширяют Employee, поэтому можно запомнить любой из этих объектов в подходящей ссылке базового класса. Так что допустимыми будут и следующие операторы.
// Manager - это Employee.
Employee moonUnit = new Manager("MoonUnit Zappa", 2, 20000, "101-11-1321", 1);
// PTSalesPerson - это Salesperson.
Salesperson jill = new PTSalesPerson("Jill", 834, 100000, "111-12-1119", 90);
Первым правилом преобразований для типов классов является то, что когда два класса связаны отношением подчиненности ("is-a"), всегда можно сохранить производный тип в ссылке базового класса. Формально его называют неявным (кон-текстуальным) приведением типов, поскольку оно "работает" только в рамках законов наследования.
Такой подход позволяет строить очень мощные программные конструкции. Предположим, например, что у нас есть класс TheMachine (машина), который поддерживает следующий статический метод, соответствующий увольнению работника.
public class TheMachine {
public static void FireThisPerson(Employee e) {
// Удалить из базы данных…
// Забрать у работника ключи и точилку…
}
}
Мы можем непосредственно передать этому методу любой производный класс класса Employee ввиду того, что эти классы связаны отношением подчиненности ("is-a").
// Сокращение штатов.
TheMaсhine.FireThisPerson(moonUnit); // "moonUnit" - это Employee.
TheMachine.FireThisFerson(jill); //"jill" - это SalesPerson.
В дальнейшем программный код использует в производном типе неявное преобразование из базового класса (Employee). Но что делать, если вы хотите уволить служащего по имени Frank Zарра (информация о котором в настоящий момент хранится в ссылке System.Object общего вида)? Если передать объект frank непосредственно в TheMaсhine.FireThisPerson() так, как показано ниже:
// Manager - это object, но… .
object frank = new Manager("Frank Zappa", 9, 40000, "111-11-1111", 5);
…
TheMachine.FireThisPerson(frank); // Ошибка!
то вы получите ошибку компиляции. Причина в том, что нельзя автоматически интерпретировать System.Object, как объект, являющийся производным непосредственно от Employee, поскольку Object не является Employee. Но вы можете заметить, что объектная ссылка указывает на объект, связанный с Employee. Поэтому компилятор будет "удовлетворен", если вы используете явное приведение типов.
В C# явное приведение типов указывается с помощью скобок, размещаемых вокруг имени типа, к которому вы хотите прийти, с последующим указанием объекта, который вы пытаетесь использовать в качестве исходного. Например:
// Приведение общего типа System.Object
// к строго типизованному Manager.
Manager mgr = (Manager)frank;
Console.WriteLine("Опционы Фрэнка: {0}", mgr.NumbOpts);
Если не объявлять специальную переменную для "целевого типа", то можно получить более компактный программный код.
// "Внутристрочное" явное приведение типов.
Console.WriteLine("Опционы Фрэнка: {0}", ((Manager)frank).NumbOpts);
Проблему, связанную с передачей ссылки System.Object методу FireThisPerson(), можно решить так, как показано ниже.
// Явное приведение типа System.Object к Employee.
TheMachine.FireThisPerson((Employee)frank);
Замечание. Попытка приведения объекта к несовместимому типу порождает в среде выполнения соответствующее исключение. Возможности структурированной обработки исключений будут рассмотрены в главе 6.
Статический метод TheMachine.FireThisPerson() строился так, чтобы он мог принимать любой тип, производный от Employee, но возникает один вопрос: как метод "узнает", какой именно производный тип передается методу. Кроме того, если поступивший параметр имеет тип Employee, то как получить доступ к специфическим членам типов SalesPerson и Manager?
Язык C# обеспечивает три способа определения того, что ссылка базового класса действительно указывает на производный тип: явное приведение типа (рассмотренное выше), ключевое слово is и ключевое слово as. Ключевое слово is возвращает логическое значение, указывающее на совместимость ссылки базового класса с данным производным типом. Рассмотрим следующий обновленный метод FireThisPerson().
public class TheMachine {
public static void FireThisPerson(Employee e) {
if (e is SalesPerson) {
Console.WriteLine("Имя уволенного продавца: {0}", e.GetFullName());
Console.WriteLine("{0} оформил(a) {1} операций…", e.GetFullName(), ((SalesPerson)e).NumbSales);
}
if (e is Manager) {
Console.WriteLine("Имя уволенного клерка: {0}", e.GetFullName());
Console.WriteLine("{0} имел(а) (1} опцион(ов)…", e.GetFullName(), ((Manager)e).NumbOpts);
}
}
}
Здесь ключевое слово is используется для того, чтобы динамически определить тип работника. Чтобы получить доступ к свойствам NumbSales или NumbOpts, вы должны использовать явное приведение типов. Альтернативой место бы быть ис-пользование ключевого слова as для получения ссылки на производный тип (если типы при этом окажутся несовместимыми, ссылка получит значение null).
SalesPerson p = е as SalesРеrson;
if (p!= null) Console.WriteLinе("Число продаж: {0}", p.NumbSales);
Замечание. Из Главы 7 вы узнаете, что такой же подход (явное приведение типов, is и as) может использоваться при получении интерфейсных ссылок из реализующего типа.
Приведение числовых типов
В завершение нашего обзора операций приведения типов в C# заметим, что преобразование числовых типов подчиняется примерно таким же правилам. Чтобы поместить "больший" числовой тип в "меньший" (например, целое число int в byte), следует использовать явное приведение типов, которое информирует компилятор о том, что вы готовы принять возможную потерю данных.
// Если "х" больше предельного значения для byte, вероятна потеря
// данных, но из главы 9 вы узнаете о "контролируемых исключениях",
// с помощью которых можно управлять результатом.
int х = 6;
byte b = (byte)x;
Когда вы сохраняете "меньший" числовой тип в "большем" (например, byte в int), тип для вас будет преобразован неявно и автоматически, так как здесь нет потерь данных.
// Приведение типа не требуется,
// int достаточно "велик" для хранения byte.
byte b = 30; int x = b;
В C# 2005 вводится новый модификатор типа partial, который позволяет определять C#-тип в нескольких файлах *.cs. Предыдущие версии языка C# требовали, чтобы весь программный код определения типа содержался в пределах одного файла *.cs. С учетом того, что C#-класс производственного уровня может содержать сотни строк программного кода, соответствующий файл может оказаться достаточно объемным.
В таких случаях было бы хорошо иметь возможность разделить реализацию типа на несколько файлов, чтобы отделить программный код, который в некотором смысле более важен, от других элементов. Например, используя для класса модификатор partial, можно поместить все открытые члены в файл с именем MyТуре_Public.cs, а приватные поля данных и вспомогательные функции – в файл MyType_Private.cs.
// MyClass_Public.cs
namespace PartialTypes {
public partial class MyClass {
// Конструкторы.
public MyClass() {}
// Открытые члены.
public void MemberA() {}
public void MemberB() {}
}
}
// MyClass_Private.cs
namespace PartialTypes {
public partial class MyClass {
// Приватные поля данных.
private string someStringData;
// Приватные вспомогательные члены.
public static void SomeStaticHelper(){}
}
}
Это, в частности, упростит задачу изучения открытого интерфейса типа для новых членов команды разработчиков. Вместо изучения единого (и большого) файла C# с целью поиска соответствующих членов, разработчики получают возможность рассмотреть только открытые члены. Конечно, после компиляции этих файлов с помощью csc.exe в результате все равно получается единый унифицированный тип (рис. 4.14).
Рис. 4.14. После компиляции парциальные типы уже не будут парциальными
Исходный код. Проект PartialTypes размещен в подкаталоге, соответствующем главе 4.
Замечание. После рассмотрения Windows Forms и ASP.NET вы поймете, что в Visual Studio 2005 ключевое слово partial используется для разделения программного кода, генерируемого инструментами разработки. Используя этот подход, вы можете сосредоточиться на поиске подходящих решений и не заботиться об автоматически генерируемом программном коде.
