Здравствуйте уважаемые коллеги!
В данной статье я постараюсь ответить на вопросы: Что такое DLL ? Для чего она нужна? И как создавать и использовать DLL при помощи Delphi .
Что такое DLL ?
Dynamic Link Library или сокращенно DLL — это библиотека, которая содержит в себе набор данных или функций для использования в других программах.
Области применения:
- Хранение ресурсов: иконки, звуки, курсоры и т.д. Экономим на размере исполняемых файлов объединяя ресурсы в единую библиотеку.
- Размещение отдельных модулей программы и форм интерфейса. Получаем возможность частичного обновления приложения, а при динамическом подключении, возможно обновлять модули без перезапуска основной программы.
- Использование в качестве плагинов (PlugIn). Предоставляем возможность расширять функционал приложения без переписывания основного кода программы.
- Библиотека может использоваться на разных языках программирования в не зависимости от языка на котором она была написана.
Создание собственной библиотеки DLL.
Для создания библиотеки заходим в меню File
-> Other
и выбираем Delphi Projects
-> Dynamic-link Library
.
Откроется текст кода с заготовкой для создания библиотеки:
Library Project1; uses System.SysUtils, System.Classes; {$R *.res} begin end.
Размещение ресурсов
Добавим иконку в библиотеку, которую будем использовать потом в основной программе.
Как добавлять ресурсы в проект подробно описано в статье.
Добавим форму «О программе».
Нажимаем File
-> New
-> VCL Form
. Добавим текст и кнопку «ОК»: 
Добавим функцию, которая будет выводить стандартный MessageBox с вопросом, кнопками «Да», «Нет» и с результатом в виде True или False .
Function YesNoDlg(const Question: PChar): boolean; stdcall; begin Result:= (MessageBox(0, Question, "Подтверждение", MB_YESNO + MB_ICONQUESTION) = ID_YES); end;
Обратите внимание на ключевое слово stdcall . Оно определяет как именно будут передаваться параметры и результаты при вызове функций. Более подробно можно почитать на странице wiki Соглашение о вызове.
Так же добавим процедуру, которая будет использоваться как плагин для основной программы. Которая будет добавлять кнопку «О программе» в основное меню программы для вызова созданного нами окна.
Код процедуры:
Procedure PlugIn(Form: TForm); stdcall; var i: integer; mi: TMenuItem; begin for i:= 0 to Form.ComponentCount - 1 do begin if (Form.Components[i].ClassName = "TMenuItem") and (Form.Components[i].Name = "miHelp") then begin mi:= TMenuItem.Create(Form.Components[i]); mi.Caption:= "О программе"; mi.OnClick:= fmAbout.onAboutButtonClick; TMenuItem(Form.Components[i]).Add(mi); Exit; end; end; end;
В процедуру в качестве параметра передается форма программы. Мы проверяем присутствует ли на ней пункт меню с именем «miHelp » и если меню нашлось, то добавляем в него свою кнопку.
Теперь укажем какие функции и процедуры можно использовать из нашей библиотеки.
Добавим строку:
Exports PlugIn, YesNoDlg;
Скомпилируем функцию Project
-> Build
или с помощью горячей клавиши Shift+F9
.
Если ошибок в коде нет, то в папке проекта должен появиться файл с расширением DLL
.
Теперь перейдем к созданию приложения, которое будет использовать нашу библиотеку.
В приложении создадим форму Main
в которой добавим компонент со следующими кнопками: Программа -> Выход и Помощь. Для последнего зададим имя — miHelp
:
Перейдем к коду формы.
Функции из библиотеки DLL
можно подключать двумя способами:
Статическим
— библиотека подключается при запуске программы. Если библиотека или имя функции не найдено, то программа выдаст ошибку и не запустится.
Динамическим
— библиотека подключается или непосредственно перед вызовом функции или по определенному событию.
Рассмотрим статический способ подключения:
Type TfmMain = class(TForm) MainMenu: TMainMenu; miProgram: TMenuItem; miExit: TMenuItem; miHelp: TMenuItem; procedure FormCreate(Sender: TObject); procedure miExitClick(Sender: TObject); private public end; procedure PlugIn(Form: TForm); stdcall; external "SampleDLL.dll"; var ...
Ключевое слово external указывает на то, что данная функция подключается из внешней библиотеки.
На событие onCreate формы добавим вызов процедуры PlugIn :
Procedure TfmMain.FormCreate(Sender: TObject); begin PlugIn(Self); end;
В качестве параметра Form передаем в процедуру текущую форму (ключевое слово Self ).
При запуске программы у нас должен появится пункт «О программе» в разделе «Помощь» главного меню.
Переходим к динамическому способу подключения.
Нам понадобятся три функции WinApi :
LoadLibrary
Загружает библиотеку в память компьютера. В качестве результата возвращает указатель на библиотеку в памяти. В случае ошибки вернет 0.
LoadLibrary(lpLibFileName: LPCWSTR): HMODULE;
lpLibFileName — Имя файла библиотеки.
GetProcAddress
Найти функцию в библиотеки по имени. Результатом будет указатель на функцию. Если функция не найдена, то вернет nil
.
GetProcAddress(hModule: HMODULE; lpProcName: LPCSTR): FARPROC;
hModule
lpProcName
— Имя функции.
FreeLibrary
Выгружает библиотеку из памяти компьютера. Результатом будет True в случае успешного выполнения и False в случае ошибки.
FreeLibrary(hLibModule: HMODULE): BOOL;
hLibModule — Указатель на загруженную библиотеку.
Теперь с помощью динамического способа получим ресурсы, нашу иконку и на кнопку «Выход» добавим вызов функции YesNoDlg
для подтверждения закрытия программы.
На то же событие onCreate добавляем код:
Procedure TfmMain.FormCreate(Sender: TObject); var DLLHandle: THandle; begin PlugIn(Self); DLLHandle:= LoadLibrary("SampleDLL.dll"); if DLLHandle = 0 then raise Exception.Create("Не удалось подключить библиотеку "SampleDLL"!"); try Self.Icon.LoadFromResourceName(DLLHandle, "my_icon"); finally FreeLibrary(DLLHandle); end; end;
И на событие onClick пункта меню «Выход»:
Procedure TfmMain.miExitClick(Sender: TObject); var DLLHandle: THandle; Dlg: function(const Question: PChar): boolean; stdcall; begin DLLHandle:= LoadLibrary("SampleDLL.dll"); if DLLHandle = 0 then raise Exception.Create("Не удалось подключить библиотеку "SampleDLL"!"); try @Dlg:= GetProcAddress(DLLHandle, "YesNoDlg"); if not Assigned(@Dlg) then raise Exception.Create("Функция с именем "YesNoDlg" не найдена в библиотеке "SampleDLL"!"); if Dlg("Выйти из программы?") then Close; finally FreeLibrary(DLLHandle); end; end;
Если вы все написали верно, то после запуска программы должна поменяться иконка формы, добавиться кнопка «О программе», при нажатии на которую будет показывать форма About и на нажатие кнопки выход программа будет запрашивать подтверждение: «Выйти из программы?».
Надеюсь вам будет полезен этот небольшой пример использования возможностей DLL
библиотек.
Исходники проекта можно скачать .
Что такое DLL - знает, как минимум, большинство пользователей PC, тем более программисты, к которым Вы, скорее всего и относитесь, раз читаете эту статью. В этой статье я постараюсь пробежаться по всем общим вопросам, касающимся DLL.
Что конкретно мы рассмотрим:
- Как обычно, из области "Hello World", мы создадим свою первую DLL.
- Научимся пользоваться функциями этой DLL из своих программ.
- Научимся просматривать функции, которые экспортирует определенная DLL.
- Может, что нибудь еще....
Процесс создания DLL
Начнем с самого простого - написание своей первой DLL, которая будет содержать всего лишь одну функцию, которая выводит сообщение "Hello World".
- Запускаем Delphi (Я использую Delphi 6).
- Далее: File -> New ->Other
На закладке New дважды щелкаем по объекту DLL Wizard. Откроется новый проект. Сохраните его, например, с именем MyFirstDLL.
Чистый модуль имеет примерно такое содержание:
Library MyFirstDLL; uses SysUtils, Classes; {$R *.res} begin end.
Теперь напишем всего лишь одну функцию, которая вызовет ShowMessage() из модуля Dialogs. Следовательно, перед началом оформления процедуры допишем в раздел Uses модуль Dialogs. Что, примерно, должно у вас получится:
Library MyFirstDLL; uses Dialogs; procedure MyFirstFunc; stdcall; begin ShowMessage("Hello World"); end; exports MyFirstFunc; begin end.
Как видите, тут нет ничего очень сложного. Единственное скажу, что можно вызывать функции как по имени, так и по индексу (номеру), для этого надо писать так:
Exports MyFirstFunc index 1;
Если что не понятно в этом коде, то все таки постарайтесь разобраться сначала сами. Думаю, что с этим проблем не будет... Но если что, то forum.! Идем дальше, как же можно теперь пользоваться этой (MyFirstFunc) функцией из других проектов?
Использование функций DLL
Первый шаг сделан, дело за малым... Как нам использовать эту функцию?
Есть, как минимум, два способа загрузки:
- Статический
- Динамический
Второй способ предпочтительнее, так во время загрузки мы можем следить за всем происходящим и можем править все ошибки, происходящие при подгружении. Но, сначала, поглядим первый способ:
Создаем новый проект, бросаем на форму одну кнопку и по событию OnClick этой кнопки и пишем следующее:
Procedure TForm1.Button1Click(Sender: TObject); begin MyProc(); end;
Но это еще не все! В разделе implementation проекта запишите:
Implementation procedure MyProc(); stdcall; external "MyFirstDLL.dll" name "MyFirstFunc";
Готово! Компилируйте проект и жмите на кнопку! Если показалось ваше сообщение, то все ок!
Теперь рассмотрим способ с динамической загрузкой. Для этого метода используют функцию LoadLibrary(), а в конце, для выгрузки - FreeLibrary().
Посмотрите на примере:
Procedure TForm1.Button1Click(Sender: TObject); type TMyFunc = procedure; var DLLInstance: THandle; MyFunc: TMyFunc; begin DLLInstance:= LoadLibrary(PChar("MyFirstDLL.dll")); if (DLLInstance = 0) then begin MessageDlg("Невозможно загрузить DLL", mtError, , 0); Exit; end; try @MyFunc:= GetProcAddress(DLLInstance, "MyFirstFunc"); if Assigned(@MyFunc) then MyFunc() else MessageDlg("Не найдена искомая процедура!.", mtError, , 0); finally FreeLibrary(DLLInstance); end; end;
После успешной загрузки DLL функцией LoadLibrary(), с помощью GetProcAddress() найдем адрес нашей функции, по которому и будем вызывать нашу процедуру из DLL. В конце, обязательно, надо сделать FreeLibrary(). Это настолько важно, что весь код после успешной загрузки, вполть до FreeLibrary() я заключил в блок try finally. Это гарантирует выполнение FreeLibrary, даже если при выполнении действий внутри блока try except, возникнет непредвиденная ошибка в виде исключения (Exception).
Дело в том, что успешные вызовы LoadLibrary и FreeLibrary обязательно должны быть парными. И вот почему. Система, для каждой загружаемой процессом библиотеки, ведет внутри себя счетчик, который увеличивается на 1 при каждом успешном вызове LoadLibrary. Соответственно, при выполнени FreeLibrary, она уменьшает этот счетчик, и если он становится равным нулю, то это означает что данная библиотека более не нужна данному процессу, и ее можно смело удалить из памяти.
Если-же правило парности не соблюдать, то это может привести либо к преждевременной выгрузке (при лишнем FreeLibrary) библиотеки из памяти, либо к ее "застревании" там (при недостатке FreeLibrary).
При соблюдении же этого правила, можно не заботиться о возможной вложенности вызовов LoadLibrary / FreeLibrary.
Просмотр функций определенной DLL
Теперь посмотрим, как можно извлечь все имена функций из файлов PE формата, к которым и относится DLL. Структуру PE формата мы тут рассматривать не будем, следовательно, и исходник будет без пояснений.
Итак, создайте новый проект, бросьте на форму ListBox, в нём мы будем показывать имена функций.
Вот весь проект:
Unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type TForm1 = class(TForm) lb: TListBox; procedure FormCreate(Sender: TObject); private { Private declarations } cmdline: String; ImageBase: DWord; DosHeader: PImageDosHeader; PeHeader: PImageNtHeaders; PExport: PImageExportDirectory; pname: PDWord; name: PChar; public { Public declarations } end; var Form1: TForm1; implementation {$R *.dfm} procedure TForm1.FormCreate(Sender: TObject); procedure FatalOsError; begin ShowMessage(SysErrorMessage(GetLastError())); Abort; end; Var i: Integer; begin try if (ParamCount() IMAGE_DOS_SIGNATURE) then FatalOsError; PEHeader:= PImageNtHeaders(DWord(ImageBase) + DWord(DosHeader^._lfanew)); if (PEHeader^.Signature IMAGE_NT_SIGNATURE) then FatalOsError; PExport:= PImageExportDirectory(ImageBase + DWord(PEHeader^.OptionalHeader.DataDirectory.VirtualAddress)); pname:= PDWord(ImageBase + DWord(PExport^.AddressOfNames)); For i:= 0 to PExport^.NumberOfNames - 1 do begin name:= PChar(PDWord(DWord(ImageBase) + PDword(pname)^)); lb.Items.Add(name); inc(pname); end; finally FreeLibrary(ImageBase); end; except Application.ShowMainForm:= False; Application.Terminate; end; end; end.
Если вы захотите сами разобраться в коде и у вас что-то не будет получаться, то на нашем форуме вам обязательно помогут, заходите!
Прицепляем наш Viewer ко всем DLL
У нас есть готовая DLL с функцией, есть просмотрщик функций. Осталось добавить некой функциональности для удобства дальнейшей работы. Давайте сделаем это.... В проводнике открываем любую папку. Идем в Сервис -> Свойства папки... Переходим на закладку "Типы файлов". В списке ищем формат DLL. Если такого нет, то жмем кнопку "Создать" и в поле "Расширение" пишем - DLL. Жмем ОК. Находим созданный нами тип - DLL. Выделяем его и жмем "Дополнительно". Далее "Создать", в поле "Действии" пишем то, что будет отображаться в контекстном меню, например DLL Viewer. Через обзор ищем нашу программку.
Все готово!
Теперь при клике правой кнопкой мыши по файлу формата DLL в меню будет наш DLL Viewer. Выбираем его и смотрим все функции!
Это все, спасибо за внимание!
Предлагаю вашему вниманию очередной выпуск рассылки, в котором я продолжаю обсуждать
вопросы разработки и использования DLL в Borland Delphi. Для новых подписчиков сообщаю,
что первую часть статьи они могут посмотреть в архиве рассылки, выпуск номер 13.
Прошу прощения у тех, кто писал мне, но не получил ответа. В ближайшее время постараюсь это исправить.
Итак, продолжим.
Прежде чем начать использование какой-либо процедуры или функции, находящейся в динамической библиотеке,
вам необходимо загрузить DLL в оперативную память. Загрузка библиотеки может быть осуществлена
одним из двух способов: статическая загрузка и динамическая загрузка.
Оба метода имеют как преимущества, так и недостатки.
Статическая загрузка означает, что динамическая библиотека загружается автоматически
при запуске на выполнение использующего ее приложения. Для того чтобы использовать такой способ загрузки,
вам необходимо воспользоваться ключевым словом external при описании экспортируемой из
динамической библиотеки функции или процедуры. DLL автоматически загружается при старте программы,
и Вы сможете использовать любые экспортируемые из нее подпрограммы точно так же,
как если бы они были описаны внутри модулей приложения.
Это наиболее легкий способ использования кода, помещенного в DLL .
Недостаток метода заключается в том, что если файл библиотеки, на который
имеется ссылка в приложении, отсутствует, программа откажется загружаться.
Смысл динамического метода заключается в том, что вы загружаете библиотеку не при старте приложения,
а в тот момент, когда вам это действительно необходимо. Сами посудите, ведь если функция, описанная
в динамической библиотеке, используется только при 10% запусков программы, то совершенно нет
смысла использовать статический метод загрузки. Выгрузка библиотеки из памяти в данном случае
также осуществляется под вашим контролем. Еще одно преимущества такого способа
загрузки DLL - это уменьшение (по понятным причинам) времени старта вашего приложения.
А какие же у этого способа имеются недостатки? Основной, как мне кажется, - это то, что использование
данного метода является более хлопотным, чем рассмотренная выше статическая загрузка.
Сначала вам необходимо воспользоваться функцией Windows API LoadLibrary .
Для получения указателя на экспортируемой процедуры или функции должна
использоваться функция GetProcAddress. После завершения использования библиотеки DLL
должна быть выгружена с применением FreeLibrary.
Вызов процедур и функций, загруженных из DLL.
Способ вызова процедур и функций зависит от того, каким образом вы загрузили динамическую библиотеку,
в которой эти подпрограммы находятся.
Вызов функций и процедур из статически загруженных DLL достаточно прост. Первоначально в приложении
должно содержаться описание экспортируемой функции (процедуры). После этого вы можете их использовать
точно так же, как если бы они были описаны в одном из модулей вашего приложения.
Для импорта функции или процедуры, содержащейся в DLL , необходимо использовать
модификатор external в их объявлении. К примеру, для рассмотренной нами выше процедуры HelloWorld
в вызывающем приложении должна быть помещена следующая строка:
procedure SayHello(AForm: TForm); external myfirstdll.dll";
Ключевое слово external сообщает компилятору, что данная процедура может быть найдена в
динамической библиотеке (в нашем случае - myfirstdll.dll).
Далее вызов этой процедуры выглядит следующим образом:
...
HelloWorld(self);
...
При импорте функции и процедур будьте особенно внимательны при написании их имен и интерфейсов!
Дело в том, что в процессе компиляции приложения не производится проверки на правильность имен объектов,
экспортируемых из DLL, осуществляться не будет, и если вы неправильно описали какую-нибудь функцию,
то исключение будет сгенерировано только на этапе выполнения приложения.
Импорт из DLL может проводиться по имени процедуры (функции), порядковому номеру или
с присвоением другого имени.
В первом случае вы просто объявляете имя процедуры и библиотеку, из которой ее импортируете
(мы это рассмотрели чуть выше). Импорт по порядковому номеру требует от вас указание этого самого номера:
procedure HelloWorld(AForm: TForm); external myfirstdll.dll index 15;
В этом случае имя, которое вы даете процедуре при импорте не обязательно должно совпадать с тем,
которое было указано для нее в самой DLL. Т.е. приведенная выше запись означает,
что вы импортируете из динамической библиотеки myfirstdll.dll процедуру, которая в ней экспортировалась
пятнадцатой, и при этом в рамках вашего приложения этой процедуре дается имя SayHello.
Если вы по каким-то причинам не применяете описанный выше способ импорта,
но тем не менее хотите изменить имя импортируемой функции (процедуры), то можно воспользоваться третьим методом:
procedure CoolProcedure; external myfirstdll.dll name "DoSomethingReallyCool";
Здесь импортируемой процедуре CoolProcedure дается имя DoSomethingReallyCool.
Вызов процедур и функций, импортируемых из динамически загружаемых библиотек
несколько более сложен, чем рассмотренный нами выше способ. В данном случае требуется объявить
указатель на функцию или процедуру, которую вы собираетесь использовать.
Помните процедуру HelloWorld? Давайте посмотрим, что необходимо сделать для того,
чтобы вызвать ее на выполнение в случае динамической загрузки DLL. Во-первых, вам
необходимо объявить тип, который описывал бы эту процедуру:
type
THelloWorld = procedure(AForm: TForm);
Теперь вы должны загрузить динамическую библиотеку, с помощью GetProcAddress получить
указатель на процедуру, вызвать эту процедуру на выполнение, и, наконец, выгрузить DLL из памяти.
Ниже приведен код, демонстрирующий, как это можно сделать:
DLLInstance: THandle ;
HelloWorld: THelloWorld;
begin
{ загружаем DLL }
{ получаем указатель }
{ вызываем процедуру на выполнение }
HelloWorld(Self ) ;
{ выгружаем DLL из оперативной памяти }
FreeLibrary(DLLInstance) ;
end ;
Как уже говорилось выше, одним из недостатков статической загрузки DLL является невозможность
продолжения работы приложения при отсутствии одной или нескольких библиотек. В случае с динамической
загрузкой у вас появляется возможность программно обрабатывать такие ситуации и не допускать, чтобы программа
вываливалась» самостоятельно. По возвращаемому функциями LoadLibrary и GetProcAddress значениям можно
определить, успешно ли прошла загрузка библиотеки и найдена ли в ней необходимая приложению процедура.
Приведенный ниже код демонстрирует это.
procedure TForm1.DynamicLoadBtnClick (Sender: TObject ) ;
type
THelloWorld = procedure (AForm: TForm) ;
DLLInstance: THandle ;
HelloWorld: THelloWorld;
begin
DLLInstance:= LoadLibrary("myfirstdll.dll" ) ;
if DLLInstance = 0 then begin
MessageDlg("Невозможно загрузить DLL" , mtError, [ mbOK] , 0 ) ;
Exit ;
end ;
@HelloWorld:= GetProcAddress(DLLInstance, "HelloWorld" ) ;
if @HelloWorld nil then
HelloWorld (Self )
else
MessageDlg("Не найдена искомая процедура!." , mtError, [ mbOK] , 0 ) ;
FreeLibrary(DLLInstance) ;
end ;
В DLL можно хранить не только код, но и формы.
Причем создание и помещение форм в динамическую библиотеку не слишком сильно отличается от работы
с формами в обычном проекте. Сначала мы рассмотрим, каким образом можно написать библиотеку,
содержащую формы, а затем мы поговорим об использовании технологии MDI в DLL.
Разработку DLL, содержащую форму, я продемонстрирую на примере.
Итак, во-первых, создадим новый проект динамической библиотеки.
Для этого выберем пункт меню File|New, а затем дважды щелкнем на иконку DLL .
После этого вы увидите примерно следующий код:
Сохраните полученный проект. Назовем его DllForms.dpr.
Теперь следует создать новую форму. Это можно сделать по-разному.
Например, выбрав пункт меню File|New Form. Добавьте на форму какие-нибудь компоненты.
Назовем форму DllForm и сохраним получившийся модуль под именем DllFormUnit.pas .
Вернемся к главному модулю проекта и поместим в него функцию ShowForm, в задачу которой будет входить
создание формы и ее вывод на экран. Используйте для этого приведенный ниже код.
Form: TDLLForm;
begin
Result:= Form.ShowModal ;
Form.Free ;
end ;
Обращаю внимание, что для того, чтобы проект был скомпилирован без ошибок, необходимо добавить в секцию uses модуль Forms .
Экспортируем нашу функцию с использованием ключевого слова exports:
exports
ShowForm;
Компилируем проект и получаем файл dllforms.dll. Эти простые шаги - все,
что необходимо сделать для сОбратите внимание, что функция ShowForm объявлена с использованием ключевого слова stdcall .
Оно сигнализирует компилятору использовать при экспорте функции соглашение
по стандартному вызову (standard call calling convention). Экспорт функции таким образом создает
возможность использования разработанной DLL не только в приложениях, созданных в Delphi.
Соглашение по вызову (Calling conventions) определяет, каким образом передаются аргументы при вызове функции.
Существует пять основных соглашений: stdcall, cdecl, pascal, register и safecall.
Подробнее об этом можно узнать, посмотрев раздел " Calling Conventions " в файле помощи Delphi.
Также обратите внимание, что значение, возвращаемое функцией ShowForm ,
соответствует значению ShowModal. Таким образом вы можете передавать некоторую информацию
о состоянии формы вызывающему приложению.
Ниже представлено два листинга, первый из которых содержит полный код файла
проекта DLL (модуль с формой здесь не приводится), а второй - модуль вызывающего приложения,
в котором используется только что разработанная нами библиотека.
library DllForms;
uses
DllFormUnit in "DllFormUnit.pas" {DllForm} ;
{$R *.RES}
function ShowForm: Integer ; stdcall ;
Form: TDLLForm;
begin
Form:= TDLLForm.Create (Application) ;
Result:= Form.ShowModal ;
Form.Free ;
end ;
begin
end .
unit TestAppUnit;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics,
Controls, Forms, Dialogs, StdCtrls;
type
TForm1 = class (TForm)
Button1: TButton;
procedure Button1Click(Sender: TObject ) ;
private
{ Private declarations }
public
{ Public declarations }
end ;
Form1: TForm1;
function ShowForm: Integer ; stdcall ;
External "dllforms.dll" ;
implementation
{$R *.DFM}
procedure TForm1.Button1Click (Sender: TObject ) ;
begin
end ;
end .
Прошу заметить, что при экспорте функции также было использовано ключевое слово stdcall.
Следует обратить особое внимание на работу с дочерними формами в DLL. Если, к примеру,
в вызывающем приложении главная форма имеет значение свойства FormStyle, равным MDIForm,
то при попытке вызова из DLL MDIChild-формы, на экране появится сообщение об ошибке,
в котором будет говориться, что нет ни одной активной MDI-формы.
В тот момент, когда вы пытаетесь показать ваше дочернее окно, VCL проверяет корректность
свойства FormStyle главной формы приложения. Однако в нашем случае все вроде бы верно.
Так в чем же дело? Проблема в том, что при проведении такой проверки, рассматривается объект Application,
принадлежащий не вызывающему приложению, а собственно динамической библиотеке.
Ну, и естественно, поскольку в DLL нет главной формы, проверка выдает ошибку.
Для того чтобы избежать такой ситуации, надо назначить объекту Application динамической библиотеки
объект Application вызывающего приложения. Естественно, это заработает только в том случае,
когда вызывающая программа - VCL-приложение. Кроме того, перед выгрузкой библиотеки из памяти
необходимо вернуть значение объекта Application библиотеки в первоначальное состояние.
Это позволит менеджеру памяти очистить оперативную память, занимаемую библиотекой.
Следовательно, вам нужно сохранить указатель на «родной» для библиотеки объект Application
в глобальной переменной, которая может быть использована при восстановлении его значения.
Итак, вернемся немного назад и перечислим шаги, необходимые нам для работы с помещенным
в DLL MDIChild-формами.
В динамической библиотеке создаем глобальную переменную типа TApplication.
Сохраняем указатель на объект Application DLL в глобальной переменной.
Объекту Application динамической библиотеки ставим в соответствие указатель на Application
вызывающего приложения.
Создаем MDIChild-форму и работаем с ней.
Возвращаем в первоначальное состояние значение объекта Application динамической библиотеки
и выгружаем DLL из памяти.
Первый шаг прост. Просто помещаем следующий код в верхней части модуля DLL:
var
DllApp: TApplication;
Затем создаем процедуру, которая будет изменять значение объекта Application и создавать дочернюю форму.
Процедура может выглядеть примерно так:
procedure ShowMDIChild(MainApp: TApplication) ;
Child: TMDIChild;
begin
if not Assigned (DllApp) then begin
DllApp:= Application;
Application:= MainApp;
end ;
Child:= TMDIChild.Create (Application.MainForm ) ;
Child.Show ;
end ;
Все, что нам теперь необходимо сделать, - это предусмотреть возвращение значения объекта Application
в исходное состояние. Делаем это с помощью процедуры MyDllProc:
procedure MyDLLProc(Reason: Integer ) ;
begin
if Reason = DLL_PROCESS_DETACH then
{ DLL is выгружается. Восстанавливаем значение указателя Application}
if Assigned (DllApp) then
Application:= DllApp;
end ;
Вместо заключения.
Использование динамически подключаемых библиотек не так сложно, как это может показаться на первый взгляд.
Использование динамически подключаемых библиотек не так сложно, как это может показаться на первый взгляд.
DLL предоставляют широчайшие возможности для оптимизации работы приложений,
а также работы самих программистов. Используйте DLL и, возможно, ваша жизнь станет легче!
http://subscribe.ru/
E-mail: [email protected] Поиск
на АПОРТ на Subscribe.Ru
В среде программирования Delphi предусмотрены встроенные средства для быстрого создания DLL-библиотек.
Давайте для определенности создадим библиотеку, содержащую функцию
GetArea(a, b, c: REAL):REAL.
Данной функции на вход подаются длины сторон треугольника. Функция возвращает площадь заданного треугольника:
p:=(a+b+c)/2;
Result:=SQRT(p*(p-a)*(p-b)*(p-c))
Запускаем D elphi , а дальше действуем нетрадиционно. Выбираем пункты меню F ile N ew O ther , в открывшемся окошке на закладке N ew щелкаем по пиктограмме DLL W izard . (алгоритм зависит от версии)
При этом создается файл заготовки DLL-библиотеки. Он очень похож на обычный модуль (unit ) D elphi , только начинается с оператора Library . Сохраните проект под именем, которое в будущем получит DLL-библиотека, скажем, GetA . Название GetArea использовать нельзя – оно уже занято именем функции.
Теперь после оператора USES пишем текст нашей функции, но с некоторыми изменениями в заголовке:
FUNCTION GetArea(a, b, c:REAL):REAL; export;
Ключевое слово EXPORT указывает на то, что данная функция является экспортируемой и будет видна из внешних программ.
После текста функции припишем
GetArea ;
В операторе EXPORTS перечисляются все процедуры и функции, экспортируемые из библиотеки. Это своего рода каталог нашей библиотеки.
Запустить на выполнение библиотеку невозможно, ее можно только откомпилировать. Для этого выполним пункт меню Project → Build. Если все было сделано правильно, на диске в текущей директории будет создан файл с именем geta.dll. Это и есть наша библиотека.
Важное замечание : существует определенная тонкость при передаче процедурам и функциям, находящимся в библиотеке, параметров типа STRING.
Для того, чтобы можно было передавать параметры типа STRING, придется в операторы USES и библиотеки, и вызывающей ее программы прописать подключение модуля ShareMem, да еще и обязательно так, чтобы этот модуль шел первым в списке. Мало того, вместе с библиотекой придется обязательно прилагать файл borlndmm.dll (он входит в поставку Delphi). Избежать этой ситуации просто: следует для параметров текстового типа использовать типы данных ShortString (это обычная строка, но длиной до 255 символов) и PChar (указатель на текстовую строку).
Вызов dll
Существуют два способа вызова процедур и функций из DLL. В первом случае мы заранее, на этапе разработки программы, знаем, какую DLL будем к ней подключать (чаще всего мы сами и создаем эту DLL). Во втором случае мы подключаемся к произвольной библиотеке, в том числе и "чужой".
Статическое связывание
Для реализации первого способа, называемого статическим связыванием , создайте новое обычное приложение, поместите на форму три поля ввода LabeledEdit1…LabeledEdit3, кнопку и компонент Tlabel. После оператора IMPLEMENTATION добавьте строчку, обеспечивающую импорт функции GetArea из библиотеки geta.dll:
Function GetArea(a,b,c:real):REAL; FAR; EXTERNAL "geta";
Слово EXTERNAL указывает на то, что тело данной функции находится в библиотеке с указанным именем, а слово FAR задает применение "длинных" четырехбайтных адресов, что необходимо, так как вызывающая программа находится на одной странице памяти, а DLL-библиотека – на другой. Разумеется, файл geta.dll надо поместить в ту же директорию, где находятся все файлы текущего приложения.
В обработчике нажатия кнопки надо создать массив и передать его библиотечный функции, а результат вывести на экран:
procedure TForm1.Button1Click(Sender: TObject);
Работа с DLL библиотеками
DLL- Dynamic Link Library иначе динамически подключаемая библиотека, которая позволяет многократно применять одни и те же функции в разных программах. На самом деле довольно удобное средство, тем более что однажды написанная библиотека может использоваться во многих программах. В сегодняшнем уроке мы научимся работать с dll и конечно же создавать их!
Ну что ж начнём!
Для начала создадим нашу первую Dynamic Link Library! Отправляемся в Delphi и сразу же лезем в меню File -> New ->Other.
Выбираем в списке Dynamic-Link Library (в версиях младше 2009 Delphi пункт называется DLL Wizard).
В результате у нас появляется лишь окно с кодом, заметьте никакой формы у нас здесь нет!
Теперь начинается самое интересное. Напишем наши первые процедуры в библиотеке.
| library Project2; //Вы, наверное уже заметили, что вместо program //при создании dll используется слово library. //Означающее библиотека. uses SysUtils, dialogs, Classes; // Внимание! Не забудьте указать эти модули, // иначе код работать не будет {$R *.res} {В ЭТУ ЧАСТЬ ПОМЕЩАЕТСЯ КОД DLL} Procedure FirstCall; stdcall; export; //Stdcall – При этом операторе параметры помещаются в стек //справа налево, и выравниваются на стандартное значение //Экспорт в принципе можно опустить, используется для уточнения //экспорта процедуры или функции. Begin ShowMessage("Моя первая процедура в dll"); //Вызываем сообщение на экран End; Procedure DoubleCall; stdcall; export; Begin ShowMessage(" Моявтораяпроцедура"); //Вызываем сообщение на экран End; Exports FirstCall, DoubleCall; //В Exports содержится список экспортируемых элементов. //Которые в дальнейшем будут импортироваться какой-нибудь программой. begin End. |
На этом мы пока остановимся т.к. для простого примера этого будет вполне достаточно. Сейчас сохраняем наш проект, лично я сохранил его под именем Project2.dll и нажимаем комбинацию клавиш CTRL+F9 для компиляции библиотеки. В папке, куда вы сохранили dpr файл обязан появится файл с расширением dll, эта и есть наша только что созданная библиотека. У меня она называется Project2.dll
Займёмся теперь вызовом процедур из данной библиотеки. Создаём по стандартной схеме новое приложение. Перед нами ничего необычного просто форма. Сохраняем новое приложение в какую-нибудь папку. И в эту же папку копируем только что созданную dll библиотеку. Т.е. в данном примере Project2.dll
Теперь вам предстоит выбирать, каким способом вызывать функции из библиотеки. Всего существует два метода вызова.
Способ № 1
Пожалуй, это самый простой метод вызова процедур находящихся в библиотеке.
Идеально подходит для работы только с одной библиотекой.
Ну что поехали...
После ключевого слова implementation прописываем следующий код:
Здесь, как вы уже наверное догадались, мы сообщаем программе названия наших процедур и говорим, что они находятся в dll библиотеке, в моем случае с именем Project2.dll
Теперь для того, что бы вызвать данные процедуры нам необходимо лишь вставить их названия в любое место кода, что мы сейчас и сделаем. Кидаем на форму 2 компонента Button с закладки Standart и создаем на каждой обработчик событий OnClick
OnClick первойкнопки:
OnClick второйкнопки:
Вот и все!
Способ № 2:
Сложнее чем первый, но у него есть свои плюсы, а самое главное, что он идеально подходит для плагинов.
Для применения данного метода, первым делом объявляем несколько глобальных переменных:
Затем после ключевого слова implementation напишем процедуру которая будет загружать нашу библиотеку:
| Procedure LoadMyLibrary(FileName: String); Begin LibHandle:= LoadLibrary(PWideChar(FileName)); //Загружаем библиотеку! // Внимание! PChar для версий ниже 2009 Delphi If LibHandle = 0 then begin MessageBox(0," Невозможнозагрузитьбиблиотеку",0,0); Exit; End; FirstCall:= GetProcAddress(LibHandle,"FirstCall"); //Получаем указатель на объект //1-ий параметр ссылка на модуль библиотеки //2-ой параметр имя объекта в dll DoubleCall:= GetProcAddress(LibHandle,"DoubleCall"); If @FirstCall = nil then begin //Проверяем на наличие этой функции в библиотеке. MessageBox(0,"Невозможно загрузить библиотеку",0,0); Exit; End; If @DoubleCall = nil then begin //Проверяем на наличие этой функции в библиотеке. MessageBox(0,"Невозможно загрузить библиотеку",0,0); Exit; End; End |
После чего на форме создаем, обработчик событий OnCreate, в котором с помощью только что созданной процедуры мы загрузим нашу библиотеку
| Procedure TForm1.FormCreate(Sender: TObject); Begin LoadMyLibrary("Project2.dll"); End; |
Теперь опять же, для того, что бы вызвать необходимые процедуры из нашей библиотеки нам необходимо лишь вставить их названия в любое место кода. Для этого кидаем на форму 2 компонента Button с закладки Standart и создаем на каждой обработчик событий OnClick
OnClick первойкнопки:
| Procedure TForm1.Button1Click(Sender: TObject); Begin FirstCall; // Имя процедуры, которая находится в dll End; |
OnClick второйкнопки:
| Procedure TForm1.Button2Click(Sender: TObject); Begin DoubleCall; // Имя процедуры, которая находится в dll End; |
Ну и напоследок создаем обработчик событий OnDestroy на форме, в котором выгружаем dll библиотеку из памяти
Вот и все! Второй способ получился довольно громоздкий, но его плюс в уточнении хранящегося объекта в библиотеке.