intTarget(9);
Console.ReadLine();
}
static void StringTarget(string arg) {
Console.WriteLine("arg в верхнем регистре: {0}", arg.ToUpper());
}
static void IntTarget(int arg) {
Console.WriteLine("++arg: {0}", ++arg);
}
}
}
Обратите внимание на то. что MyGenericDelegate‹T› определяет один пара-метр типа, представляющий аргумент, отправляемый целевому объекту делегата. При создании экземпляра этого типа требуется конкретизировать значение параметра типа, а также имя метода, вызываемого делегатом. Так, если вы укажете строковый тип, то отправите целевому методу строковое значение.
// Создание экземпляра MyGenericDelegate‹T›
// со значением string для параметра типа.
MyGenericDelegate‹string› strTarget = new MyGenericDelegate‹string›(StringTarget);
strTarget("Некоторые строковые данные");
С учетом формата объекта strTarget метод StringTarget() должен теперь получить в качестве параметра одну строку.
static void StringTarget(string arg) {
Console.WriteLine("arg в верхнем регистре: {0}", arg.ToUpper());
}
Имитация обобщенных делегатов в .NET 1.1
Как видите, обобщенные делегаты предлагают более гибкий подход для указания вызываемых методов. В рамках .NET 1.1 аналогичного результата можно достичь с помощью базового System.Object.
public delegate void MyDelegate(object arg);
Это позволяет посылать любой тип данных целевому объекту делегата, но при этом не гарантируется типовая безопасность, а кроме того, остаются нерешенными проблемы создания объектных образов. Предположим, например, что мы создали два экземпляра MyDelegate, которые указывают на один и тот же метод MyTarget. Обратите внимание на проблемы создания объектных образов и восстановления значений, а также на отсутствие гарантий типовой безопасности.
class Program {
static void Main(string[] args) {
…
// Регистрация цели с помощью
// 'традиционного' синтаксиса делегата.
MyDelegate d = new MyDelegate(MyTarget) d("Дополнительные строковые данные");
// Регистрация цели с помощью
// группового преобразования метода.
MyDelegate d2 = MyTarget;
d2(9); // Проблема объектного образа.
…
}
// Ввиду отсутствия типовой безопасности мы должны
// определить соответствующий тип до преобразования.
static void MyTarget(object arg) {
if (arg is int) {
int i = (int)arg; // Проблема восстановления значения.
Console.WriteLine("++arg: {0}", ++i);
}
if (arg is string) {
string s = (string) arg;
Console.WriteLine("arg в верхнем регистре: {0}", s.ToUpper());
}
}
}
Когда вы посылаете целевому объекту тип, характеризуемый значением, это значение (конечно же) "упаковывается" в объект и "распаковывается" после его получения целевым методом. Точно так же, поскольку поступающий параметр может быть всем чем угодно, вы должны динамически проверить соответствующий тип перед тем, как выполнить преобразование. С помощью обобщенных делегатов вы можете получить всю необходимую гибкость без "проблем".
Несколько слов о вложенных делегатах
Завершим эту главу рассмотрением еще одного аспекта обобщенных делегатов. Вы знаете, что делегаты могут быть вложены в тип класса, что должно означать тесную ассоциацию между этими двумя ссылочными типами. Если тип-контейнер при этом оказывается обобщенным, вложенный делегат может использовать в своем определении параметры типа.
// Вложенные обобщающе делегаты могут иметь доступ к параметрам
// обобщенного типа-контейнера.
public class MyList‹T› {
private List‹T› listOfData = new List‹T›();
public delegate void ListDelegate(T arg);
}
Исходный код. Проект GenericDetegate размещен в подкаталоге, соответствующем главе 10.
Резюме
Обобщения можно обоснованно считать главным из усовершенствований, предложенных в C# 2005. Как вы могли убедиться, обобщенный элемент позволяет указать "заполнители" (т.е. параметры типа), которые конкретизируются в момент создания типа (или вызова, в случае обобщенных методов). По сути, обобщения дают решение проблем объектных образов и типовой безопасности, усложняющих разработку программ в среде .NET 1.1.
Чаще всего вы будете просто использовать обобщенные типы, предлагаемые библиотеками базовых классов .NET, но можно создавать и свои собственные обобщенные типы. При создании обобщенных типов можно указать любое число ограничений, чтобы повысить уровень типовой безопасности и гарантировать, что соответствующие операции будут выполняться с "известными величинами".
ЧАСТЬ III. Программирование компоновочных блоков .NET
ГЛАВА 11. Компоновочные блоки .NET
Любое из приложений, описанных в этой книге в предыдущих десяти главах, было обычным "автономным" приложением, вся программная логика которого целиком содержались в одном выполняемом файле (*.exe). Однако одной из главных задач платформы .NET является многократное использование программного кода, при котором приложения могут использовать типы, содержащиеся в различных внешних компоновочных блоках (называемых также библиотеками программного кода). Целью этой главы будет подробное рассмотрение вопросов создания, инсталляции и конфигурации компоновочных блоков .NET.
Сначала мы рассмотрим различия между одномодульными и многомодульными компоновочными блоками, а также между "приватными" и "общедоступными" компоновочными блоками. Затем мы выясним, как среда, выполнений .NET определяет параметры размещения компоновочного блока, и попытаемся понять роль GAC (Global Assembly Cache – глобальный кэш компоновочных блоков), файлов конфигурации приложения (файлы *.config), политики публикации компоновочных блоков и пространства имен System.Configuration.
Роль компоновочных блоков .NET
Приложения .NET строятся путем связывания произвольного числа компоновочных блоков. С точки зрения упрощенного подхода компоновочный блок является двоичным файлом, включающим свое описание, снабженным номером версии и поддерживаемым средой CLR (Common language Runtime – общеязыковая среда выполнения). Несмотря на тот факт, что компоновочные блоки .NET имеют такие же расширения (*.exe или *.dll), как и другие двоичные файлы Win32 (включая все еще используемые серверы COM), по сути, компоновочные блоки .NET имеют с ними очень мало общего. Поэтому для начала мы рассмотрим некоторые преимущества, обеспечиваемые форматом компоновочного блока.
Расширенные возможности многократного использования программного кода
При построений консольных приложений в предыдущих главах могло показаться, что в создаваемом вами выполняемом компоновочном блоке содержатся все функциональные возможности соответствующего приложения. На самом же деле ваши приложения использовали множество типов, предлагаемых всегда доступной библиотекой программного кода .NET, mscorlib.dll (напомним, что компилятор C# ссылается на mscorlib.dll автоматически), а также библиотекой System.Windows.Forms.dll.
Вы, наверное, знаете, что библиотека программного кода (также называемая библиотекой классов) представляет собой файл *.dll, содержащий типы, доступные для использования внешними приложениями. При создании выполняемого компоновочного блока используются компоновочные блоки, предлагаемые системой, а также пользовательские компоновочные блоки. При этом файл библиотеки программного кода не обязательно имеет вид *.dll, поскольку выполняемый компоновочный блок может использовать и типы, определенные во внешнем выполняемом файле. В этой связи файл *.exe тоже можно считать "библиотекой программного кода".
Замечание. До появления Visual Studio 2005 единственную возможность сослаться на выполняемую библиотеку программного кода обеспечивал флаг /reference компилятора C#. Но теперь ссылаться на компоновочные блоки *.exe позволяет и диалоговое окно Add Reference (Добавление ссылки) в Visual Studio 2005.
Независимо от того, как упакована библиотека программного кода, платформа .NET позволяет использовать типы в независимой от языка форме. Например, можно создать библиотеку программного кода в C# и использовать эту библиотеку в любом другом языке программирования .NET. При этом можно не только создавать экземпляры типов в рамках других языков, но и получить производные таких типов. Базовый класс, определенный в C#, можно расширить с помощью класса, созданного в Visual Basic .NET. Интерфейсы, определенные в Pascal .NET, могут реализовываться структурами, определенными в C#. Смысл в том, что при разделении единого и монолитного выполняемого программного кода на множество компоновочных блоков .NET вы получаете языково-нейтральную форму программного кода, пригодного для многократного использования.
