Console.WriteLine("***** Информация о компоновочном блоке *****");
Console.WriteLine("Загружен из GAC? {0}", a.GlobalAssemblyCache);
Console.WriteLine("Имя: {0}", a.GetName().Name);
Console.WriteLine("Версия: {0}", a.GetName().Version);
Console.WriteLine("Культура: {0}", a.GetName().CultureInfo.DisplayName);
Type[] types = a.GetTypes();
for (int i = 0; i ‹ 20; i++) Console.WriteLine("Тип: {0}", types[i]);
}
}
static void Main(string[] args) {
Console.WriteLine("***** Отображение общедоступных КБ *****n");
// Загрузка System.Windows.Forms.dll из GAC.
string displayName = null;
displayName = "System.Windows.Forms," +
"Version=2.0.0.0," +
"PublicKeyToken=b77а5c561934e089" +
@"Culture=''";
Assembly asm = Assembly.Load(displayName);
DisplayInfo(asm);
Console.ReadLine();
}
}
}
Исходный код. Проект SharedAsmReflector размещен в подкаталоге, соответствующем главе 12.
Чудесно! К этому моменту нашего обсуждения вы должны понять, как использовать некоторые базовые элементы из пространства имен System.Reflection для чтения метаданных компоновочного блока во время выполнения. Здесь я готов признать, что, несмотря на "фактор красоты" предлагаемого подхода, вам по роду своей деятельности вряд ли придется строить пользовательские навигаторы объектов. Но не следует забывать о том, что сервисы отображения являются основой целого ряда других, очень широко используемых подходов в программировании, включая и динамическое связывание.
Динамическое связывание
Упрощенно говоря, динамическое связывание, или динамическая привязка, - это подход, с помощью которого можно создавать экземпляры заданного типа и вызывать их члены в среде выполнения и условиях, когда во время компиляции о типе еще ничего не известно. При построении приложения, использующего динамическое связывание в отношении некоторого типа из внешнего компоновочного блока нет смысла устанавливать ссылку на такой компоновочный блок. Поэтому манифест вызывающей стороны и не содержит прямой ссылки.
На данном этапе обсуждения значение динамического связывания может казаться вам непонятным. Если вы имеете возможность использовать "статическую привязку" к типу (например, установить ссылку на компоновочный блок и поместить тип в память, используя ключевое слово C# new), то в этом случае так и нужно сделать. Статическое связывание позволяет обнаружить ошибки уже во время компиляции, а не во время выполнения программы. Однако динамическое связывание оказывается очень важным для построения приложений, обладающих более гибкими возможностями расширения.
Класс System.Activator
Класс System.Activator обеспечивает возможность реализации процесса динамической привязки в .NET. Кроме методов, унаследованных от System.Object, сам класс Activator определяет очень небольшое множество членов, многие из которых относятся к средствам удаленного взаимодействия .NET (cм. главу 18). Для нашего примера нам понадобится только метод Activator.CreateInstance(), который используется для создания экземпляра типа в рамках динамической привязки.
Этот метод имеет множество перегруженных вариаций, что обеспечивает ему исключительную гибкость. Самая простая вариация члена CreateInstance() должна получить на вход объект Туре, описывающий элемент, который вы хотите динамически разместить. Создайте новое приложение с именем LateBinding и модифицируйте его метод Main() так, как показано ниже (не забудьте поместить копию CarLibrary.dll в каталог BinDebug проекта).
// Динамическое создание типа.
public class Program {
static void Main(string[] args) {
// Попытка загрузить локальную копию CarLibrary.
Assembly a = null;
try {
a = Assembly.Load("CarLibrary");
} catch(FileNotFoundException e) {
Console.WriteLine(e.Message);
Console.ReadLine();
return;
}
// Получение метаданных типа Minivan.
Type miniVan = a.GetType("CarLibrary.MiniVan");
// Динамическое создание Minivan.
object obj = Activator.Createlnstance(miniVan);
}
}
Обратите внимание на то, что метод Activator.CreateInstance() возвращает обобщенный System.Object, а не строго типизированный MiniVan. Поэтому если к переменной obj вы примените операцию, обозначаемую точкой, то не увидите никаких членов типа MiniVan. На первый взгляд, можно предположить, что эта проблема решается с помощью явного преобразования типа, но ведь программа не имеет никаких указаний на то, что MiniVan должен иметь при выборе какие-либо преимущества.
Весь смысл динамической привязки заключается в создании экземпляров объектов, для которых нет статической информации. Но как при этом можно вызвать методы объекта MiniVan, сохраненного в переменной System.Object? Ответ: с помощью отображений.
Вызов методов без параметров
Предположим, что нам нужно вызвать метод TurboBoost() типа MiniVan. Вы помните, что этот метод приводит двигатель в "абсолютно нерабочее" состояние и генерирует появление информационного блока сообщения. Первым нашим шагом должно быть получение типа MethodInfо для метода TurboBoost() с помощью Type.GetMethod(). Получив MethodInfo, мы сможем вызвать Minivan.TurboBoost() с помощью Invoke(). Для MethodInfo.Invoke() необходимо указать все параметры, которые должны быть переданы методу, представленному с помощью MethodInfo. Эти параметры представляются массивом System.Object (поскольку метод может иметь любое число параметров любого типа).
Наш метод TurboBoost() не имеет параметров, поэтому для него указывается null (в данном случае это и означает отсутствие параметров у метода). Модифицируйте метод Main() так.
static void Main(string[] args) {
// Попытка загрузить локальную копию CarLibrary.
...
// Получение типа MiniVan.
Type miтiVan = a.GetType("CarLibrary.MiniVan");
// Динамическое создание MiniVan.
object obj = Activator.CreateInstance(miniVan);
// Получение информации о TurboBoost.
MethodInfo mi = miniVan.GetMethod("TurboBoost");
// Вызов метода ('null' означает отсутствие параметров) .
mi.Invoke(obj, null);
}
После этого вы сможете лицезреть сообщение, подобное показанному на рис. 12.5.
Рис. 12.5. Вызов метода в условиях динамической привязки
Вызов методов с параметрами
Чтобы показать пример динамического вызова метода, имеющего параметры, предположим, что тип MiniVan определяет метод, который называется TellChildToBeQuiet().
// Усмирение вопящих…
public void TellChildToBeQuiet(string kidName, int shameIntensity) {
for (int i = 0; i ‹ shameIntensity; i++)
MessageBox.Show("Потише, {0}!!", kidName);
}
Метод TellChildToBeQuiet() (приказать ребенку успокоиться) имеет два параметра: строковое представление имени ребенка и целое число, отражающее степень вашего раздражения. При использовании динамического связывания параметры упаковываются в массив объектов System.Object. Для вызова этого нового метода добавьте в свой метод Main() следующий программный код.
// Динамический вызов метода с параметрами.
object[] paramArray = new object[2];
paramArray[0] = "Фред"; // Имя ребенка.
paramArray[1] = 4; // Степень досады.
mi = miniVan.GetMethod("TellChildToBeQuiet");
mi.Invoke(obj, paramArray);
Выполнив эту программу, вы сможете увидеть четыре блока сообщений, отражающих намерение пристыдить юного Фреда. Надеюсь, что к этому моменту нашего обсуждения вы уже можете видеть взаимосвязь между отображением, динамической загрузкой и динамическим связыванием. Для вас еще может оставаться неясным ответ на вопрос, когда следует использовать указанный подход в приложениях. Завершающий раздел этой главы должен пролить на это свет, но пока что следующей темой нашего рассмотрения будет исследование роли атрибутов .NET.
Исходный код. Проект LateBinding размещен в подкаталоге, соответствующем главе 12.
Программирование с помощью атрибутов
Как сказано в начале этой главы, одной из задач компилятора .NET является генерирование метаданных для всех определяемых типов и для типов, на которые имеются ссылки. Кроме этих стандартных метаданных, содержащихся в каждом компоновочном блоке, платформа .NET дает программисту возможность встроить в компоновочный блок дополнительные метаданные, используя атрибуты. В сущности, атрибуты представляют собой аннотации программного кода, которые могут применяться к заданному типу (классу, интерфейсу, структуре и т.п.), члену (свойству, методу и т.п.), компоновочному блоку или модулю.
