Контрольные вопросы

19. Что такое модуль?

20. Каковы основные составные части модуля?

21. Что собой представляет заголовок модуля?

22. Как оформляется интерфейсная часть?

23. Как оформляется реализационная часть?

24. Как оформляется инициализационная часть?

Список использованной литературы

6. Голицина О.Л., Попов И.И. Основы алгоритмизации и программирования: Учебное пособие. - М.: Форум: Инфра-М, 2002.

7. Фленов М.Е. Библия Delphi. - 3-е изд. Перераб. И доп. - СПб.: БХВ-Петербург, 2011.

Практическое занятие 24

Тема: «Разработка программного продукта с использованием динамических библиотек»

Цели:

- закрепление изученного материала по применению динамических библиотек в Delphi;

- формирование навыков разработки алгоритмов с применением динамических библиотек.

Характер занятия: поисковый.

Форма организации: фронтальная.

Обеспечение занятия: ПК, ОС Windows, Delphi, ручка, карандаш, линейка, тетрадь по практическим работам.

Требования к знаниям

Перед выполнением практической работы студент должен

знать:

- основные элементы IDE Delphi и принципы работы в ней;

- основные операторы языка Object Pascal.

после выполнения практической работы студент должен

уметь:

- разрабатывать алгоритмы с использованием динамических массивов.

Теоретический материал

Динамически загружаемая библиотека (от англ. dynamically loadable library) — это библиотека подпрограмм, которая загружается в оперативную память и подключается к использующей программе во время ее работы (а не во время компиляции и сборки). Файлы динамически загружаемых библиотек в среде Windows обычно имеют расширение .dll (от англ. Dynamic-Link Library).

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

Одно из важнейших назначений динамически загружаемых библиотек — это взаимодействие подпрограмм, написанных на разных языках программирования. Например, вы можете свободно использовать в среде Delphi динамически загружаемые библиотеки, разработанные в других системах программирования с помощью языков C и C++. Справедливо и обратное утверждение — динамически загружаемые библиотеки, созданные в среде Delphi, можно подключать к программам на других языках программирования.

По структуре исходный текст библиотеки похож на исходный текст программы, за исключением того, что текст библиотеки начинается с ключевого слова library, а не слова program. Например:

library SortLib;

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

Если в теле библиотеки объявлены некоторые процедуры,

procedure BubleSort(var Arr: array of Integer);

procedure QuickSort(var Arr: array of Integer);

то это еще не значит, что они автоматически станут доступны для вызова извне. Для того чтобы это разрешить, нужно поместить имена процедур в специальную секцию exports, например:

exports

BubleSort,

QuickSort;

Перечисленные в секции exports процедуры и функции отделяются запятой, а в конце всей секции ставится точка с запятой. Секций exports может быть несколько, и они могут располагаться в программе произвольным образом.

Ниже приведен пример исходного текста простейшей динамически загружаемой библиотеки SortLib. Она содержит единственную процедуру BubleSort, сортирующую массив целых чисел методом «пузырька»:

library SortLib;

procedure BubleSort(var Arr: array of Integer);

var

I, J, T: Integer;

begin

for I := Low(Arr) to High(Arr) - 1 do

for J := I + 1 to High(Arr) do

if Arr[I] > Arr[J] then

begin

T := Arr[I];

Arr[I] := Arr[J];

Arr[J] := T;

end;

end;

exports

BubleSort;

begin

end.

Исходный текст динамически загружаемой библиотеки заканчивается операторным блоком begin...end, в который можно вставить любые операторы для подготовки библиотеки к работе. Эти операторы выполняются во время загрузки библиотеки основной программой. Эта простейшая библиотека SortLib не требует никакой подготовки к работе, поэтому ее операторный блок пустой.

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

В стандартном случае экспортное имя подпрограммы считается в точности таким, как ее идентификатор в исходном тексте библиотеки (с учетом заглавных и строчных букв). Например, если секция exports имеет следующий вид,

exports

BubleSort;

то это означает, что экспортное имя процедуры будет ’BubleSort’. При желании это имя можно сделать отличным от программного имени, дополнив описание директивой name, например:

exports

BubleSort name 'BubleSortIntegers';

В итоге, экспортное имя процедуры BubleSort будет ’BubleSortIntegers’.

Экспортные имена подпрограмм должны быть уникальны в пределах библиотеки, поэтому их нужно всегда указывать явно для перегруженных (overload) процедур и функций. Например, если имеются две перегруженные процедуры с общим именем QuickSort,

procedure QuickSort(var Arr: array of Integer); overload; // для целых чисел

procedure QuickSort(var Arr: array of Real); overload; // для вещественных

то при экспорте этим двум процедурам необходимо явно указать отличные друг от друга экспортные имена:

exports

QuickSort(var Arr: array of Integer) name 'QuickSortIntegers';

QuickSort(var Arr: array of Real) name 'QuickSortReals';

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

Механизм вызова подпрограмм основан на использовании стека.

Стек — это область памяти, в которую данные помещаются в прямом порядке, а и извлекаются в обратном, по аналогии с наполнением и опустошением магазина патронов у стрелкового оружия. Очередность работы с элементами в стеке обозначается термином LIFO (от англ. Last In, First Out — последним вошел, первым вышел).

Существует еще обычная очередность работы с элементами, обозначаемая термином FIFO (от англ. First In, First Out — первым вошел, первым вышел).

Для каждой программы на время работы создается свой стек. Через него передаются параметры подпрограмм и в нем же сохраняются адреса возврата из этих подпрограмм. Именно благодаря стеку подпрограммы могут вызывать друг друга, или даже рекурсивно сами себя.

Вызов подпрограммы состоит из «заталкивания» в стек всех аргументов и адреса следующей команды (для воврата к ней), а затем передачи управления на начало подпрограммы. По окончании работы подпрограммы из стека извлекается адрес воврата с передачей управления на этот адрес; одновременно с этим из стека выталкиваются аргументы. Происходит так называемая очистка стека. Это общая схема работы и у нее бывают разные реализации. В частности, аргументы могут помещаться в стек либо в прямом порядке (слева направо, как они перечислены в описании подпрограммы), либо в обратном порядке (справа налево), либо вообще, не через стек, а через свободные регистры процессора для повышения скорости работы. Кроме того, очистку стека может выполнять либо вызываемая подпрограмма, либо вызывающая программа. Выбор конкретного соглашения о вызове обеспечивают директивы register, pascal, cdecl и stdcall. Их смысл поясняет таблица.

Директива	Порядок занесения аргументов в стек	Кто отвечает за очистку стека	Передача аргументов через регистры
register	Слева направо	Подпрограмма	Да
pascal	Слева направо	Подпрограмма	Нет
cdecl	Справа налево	Вызывающая программа	Нет
stdcall	Справа налево	Подпрограмма	Нет

Директива register не означает, что все аргументы обязательно передаются через регистры процессора. Если число аргументов больше числа свободных регистров, то часть аргументов передается через стек.

Для процедур и функций динамически загружаемых библиотек следует выбирать соглашение stdcall:

procedure BubleSort(var Arr: array of Integer); stdcall;

procedure QuickSort(var Arr: array of Integer); stdcall;

Именно соглашение stdcall, изначально предназначенное для вызова подпрограмм операционной системы, лучше всего подходит для взаимодействия программ и библиотек, написанных на разных языках программирования. Все программы так или иначе используют функции операционной системы, следовательно они обязательно поддерживают соглашение stdcall.

Для того чтобы в прикладной программе воспользоваться процедурами и функциями библиотеки, необходимо выполнить так называемый импорт. Импорт обеспечивает загрузку библиотеки в оперативную память и привязку записанных в программе команд вызова к адресам соответствующих процедур и функций библиотеки. Существуют два способа импорта, отличающихся по удобству и гибкости программирования:

статический импорт (обеспечивается директивой компилятора external);

динамический импорт (обеспечивается функциями LoadLibrary и GetProcAddress).

Статический импорт является более удобным, а динамический — более гибким.

При статическом импорте все действия по загрузке и подключению библиотеки выполняются автоматически операционной системой во время запуска главной программы. Чтобы задействовать статический импорт, достаточно просто объявить в программе процедуры и функции библиотеки как внешние. Это делается с помощью директивы external, например:

procedure BubleSortIntegers(var Arr: array of Integer); stdcall;

external 'SortLib.dll';

procedure QuickSortIntegers(var Arr: array of Integer); stdcall;

external 'SortLib.dll';

После ключевого слова external записывается имя двоичного файла библиотеки в виде константной строки или константного строкового выражения. Вместе с директивой external может использоваться уже известная вам директива name, которая служит для явного указания экспортного имени процедуры в библиотеке. С ее помощью объявления процедур можно переписать по-другому:

procedure BubleSort(var Arr: array of Integer); stdcall;

external 'SortLib.dll' name 'BubleSortIntegers';

procedure QuickSort(var Arr: array of Integer); stdcall;

external 'SortLib.dll' name 'QuickSortIntegers';

Поместив в программу приведенные выше объявления, можно вызывать процедуры BubleSort и QuickSort, как будто они являются частью самой программы.

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

При разработке динамически загружаемых библиотек нужно всегда думать об их удобном использовании. Представим, что в библиотеке не две процедуры, а сотня, и нужны они не в одной программе, а в нескольких. В этом случае намного удобнее вынести external-объявления процедур в отдельный модуль, подключаемый ко всем программам в секции uses. Такой модуль условно называют модулем импорта. Кроме объявлений внешних подпрограмм он обычно содержит определения типов данных и констант, которыми эти подпрограммы оперируют.

Модуль импорта для библиотеки SortLib будет выглядеть так:

unit SortLib;

interface

procedure BubleSort(var Arr: array of Integer); stdcall;

procedure QuickSort(var Arr: array of Integer); stdcall;

implementation

const

DllName = 'SortLib.dll';

procedure BubleSort(var Arr: array of Integer); external

DllName name 'BubleSortIntegers';

procedure QuickSort(var Arr: array of Integer); external

DllName name 'QuickSortIntegers';

end.

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

Действия по загрузке и подключению библиотеки (выполняемые при статическом импорте автоматически) можно проделать самостоятельно, обратившись к стандартным функциям операционной системы. Таким образом, импорт можно произвести динамически во время работы программы (а не во время ее запуска).

Для динамического импорта необходимо загрузить библиотеку в оперативную память вызовом функции LoadLibrary, а затем извлечь из нее адреса подпрограмм с помощью функции GetProcAddress. Полученные адреса нужно сохранить в процедурных переменных соответствующего типа. После этого вызов подпрограмм библиотеки может выполняться путем обращения к процедурным переменным. Для завершения работы с библиотекой необходимо вызвать функцию FreeLibrary.

Ниже приведено краткое описание функций LoadLibrary, FreeLibrary и GetProcAddress.

LoadLibrary(LibFileName: PChar): HModule — загружает в оперативную память библиотеку, которая хранится на диске в файле с именем LibFileName. При успешном выполнении функция возвращает числовой описатель библиотеки, который должен использоваться в дальнейшем для управления библиотекой. Если при загрузке библиотеки призошла какая-нибудь ошибка, то возвращается нулевое значение. Если аргумент LibFileName содержит имя файла без маршрута, то этот файл ищется в следущих каталогах: в каталоге, из которого была запущена главная программа, в текущем каталоге, в системном каталоге операционной системы Windows (его точный маршрут можно узнать вызовом функции GetSystemDirectory), в каталоге, по которому установлена операционная система (его точный маршрут можно узнать вызовом функции GetWindowsDirectory), а также в каталогах, перечисленных в переменной окружения PATH.

FreeLibrary(LibModule: HModule): Bool — выгружает библиотеку, заданную описателем LibModule, из оперативной памяти и освобождает занимаемые библиотекой ресурсы системы.

GetProcAddress(Module: HModule; ProcName: PChar): Pointer — возвращает адрес подпрограммы с именем ProcName в библиотеке с описателем Module. Если подпрограмма с именем ProcName в библиотеке не существует, то функция возвращает значение nil (пустой указатель).

Приведенная ниже программа TestDynamicImport аналогична по функциональности программе TestStaticImport, но вместо статического импорта использует технику динамического импорта:

program TestDynamicImport;

{$APPTYPE CONSOLE}

uses

Windows;

type

TBubleSortProc = procedure (var Arr: array of Integer); stdcall;

TQuickSortProc = procedure (var Arr: array of Integer); stdcall;

var

BubleSort: TBubleSortProc; // указатель на функцию BubleSort

QuickSort: TQuickSortProc; // указатель на функцию QuickSort

LibHandle: HModule; // описатель библиотеки

Arr: array [0..9] of Integer;

I: Integer;

begin

LibHandle := LoadLibrary('SortLib.dll');

if LibHandle <> 0 then

begin

@BubleSort := GetProcAddress(LibHandle, 'BubleSortIntegers');

@QuickSort := GetProcAddress(LibHandle, 'QuickSortIntegers');

if (@BubleSort <> nil) and (@QuickSort <> nil) then

begin

Randomize;

for I := Low(Arr) to High(Arr) do

Arr[I] := Random(100);

BubleSort(Arr);

for I := Low(Arr) to High(Arr) do

Write(Arr[I], ' ');

Writeln;

for I := Low(Arr) to High(Arr) do

Arr[I] := Random(100);

QuickSort(Arr);

for I := Low(Arr) to High(Arr) do

Write(Arr[I], ' ');

Writeln;

end

else

Writeln('Ошибка отсутствия процедуры в библиотеке.');

FreeLibrary(LibHandle);

end

else

Writeln('Ошибка загрузки библиотеки.');

Writeln('Press Enter to exit...');

Readln;

end.

В программе определены два процедурных типа данных, которые по списку параметров и правилу вызова (stdcall) соответствуют подпрограммам сортировки BubleSort и QuickSort в библиотеке:

type

TBubleSortProc = procedure (var Arr: array of Integer); stdcall;

TQuickSortProc = procedure (var Arr: array of Integer); stdcall;

Эти типы данных нужны для объявления процедурных переменных, в которых сохраняются адреса подпрограмм:

var

BubleSort: TBubleSortProc;

QuickSort: TQuickSortProc;

В секции var объявлена также переменная для хранения целочисленного описателя библиотеки, возвращаемого функцией LoadLibrary:

var

...

LibHandle: HModule;

Программа начинает свою работу с того, что вызывает функцию LoadLibrary, в которую передает имя файла DLL-библиотеки. Функция возвращает описатель библиотеки, который сохраняется в переменной LibHandle.

LibHandle := LoadLibrary('SortLib.dll');

if LibHandle <> 0 then

begin

...

end

Если значение описателя отлично от нуля, значит библиотека была найдена на диске и успешно загружена в оперативную память. Убедившись в этом, программа обращается к функции GetProcAddress за адресами подпрограмм. Полученные адреса сохраняются в соответствующих процедурных переменных:

@BubleSort := GetProcAddress(LibHandle, 'BubleSortIntegers');

@QuickSort := GetProcAddress(LibHandle, 'QuickSortIntegers');

Обратите внимание на использование символа @ перед именем каждой переменной. Он говорит о том, что выполняется не вызов подпрограммы, а работа с ее адресом.

Если этот адрес отличен от значения nil, значит подпрограмма с указанным именем была найдена в библиотеке и ее можно вызвать путем обращения к процедурной переменной:

if (@BubleSort <> nil) and (@QuickSort <> nil) then

begin

...

BubleSort(Arr);

...

QuickSort(Arr);

...

end

По окончании сортировки программа выгружает библиотеку вызовом функции FreeLibrary.

Динамический импорт в сравнении со статическим требует значительно больше усилий на программирование, но он имеет ряд преимуществ:

Более эффективное использование ресурсов оперативной памяти по той причине, что библиотеку можно загружать и выгружать по мере надобности;

Динамический импорт помогает в тех случаях, когда некоторые процедуры и функции могут отсутствовать в библиотеке. При статическом импорте такие ситуации обрабатывает операционная система, которая выдает сообщение об ошибке и прекращает работу программы. Однако при динамическом импорте программа сама решает, что ей делать, поэтому она может отключить часть своих возможностей и работать дальше.

Динамический импорт отлично подходит для работы с библиотеками драйверов устройств. Он, например, используется самой средой Delphi для работы с драйверами баз данных.

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

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

Инициализация библиотеки происходит при ее подключении к программе и состоит в выполнении секций initialization во всех составляющих библиотеку модулях, а также в ее главном программном блоке. Завершение работы библиотеки происходит при отключении библиотеки от программы; в этот момент в каждом модуле выполняется секция finalization. Используйте эту возможность тогда, когда библиотека запрашивает и освобождает какие-то системные ресурсы, например файлы или соединения с базой данных. Запрос ресурса выполняется в секции initialization, а его освобождение — в секции finalization.

Существует еще один способ инициализации и завершения библиотеки, основанный на использовании предопределенной переменной DllProc. Переменная DllProc хранит адрес процедуры, которая автоматически вызывается при отключении библиотеки от программы, а также при создании и уничтожении параллельных потоков в программах, использующих DLL-библиотеку. Ниже приведен пример использования переменной DllProc:

library MyLib;

var

SaveDllProc: TDLLProc;

procedure LibExit(Reason: Integer);

begin

if Reason = DLL_PROCESS_DETACH then

begin

... // завершение библиотеки

end;

SaveDllProc(Reason); // вызов предыдущей процедуры

end;

begin

... // инициализация библиотеки

SaveDllProc := DllProc; // сохранение предыдущей процедуры

DllProc := @LibExit; // установка процедуры LibExit

end.

Процедура LibExit получает один целочисленный аргумент, который уточняет причину вызова. Возможные значения аргумента:

DLL_PROCESS_DETACH — отключение программы;

DLL_PROCESS_ATTACH — подключение программы;

DLL_THREAD_ATTACH — создание параллельного потока;

DLL_THREAD_DETACH — завершение параллельного потока.