Загрузка dll библиотеки в адресное пространство процесса во время работы приложения называется

Куда же на самом деле загружается динамическая библиотека, если Windows позволяет использовать загруженный код нескольким процессам? В адресное пространство процесса? Но ведь тогда, когда процесс загрузивший DLL прекратить работу и выгрузится из памяти операционной системой, другой процесс потерпит фиаско!

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

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

Также буфер может быть открыт в гибридном режиме, при котором его начальное содержимое копируется из файла, но дальнейшие изменения обратно не транслируются. Официально это называется Copy-on-Write, копирование при записи, — то есть при записи в участок файла поверх него как бы создаётся перехватывающая заплатка с копией содержимого этого участка.

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

С точки зрения операционной системы это выглядит так:

^{Виртуальная памяти процессов — физическая память — файл на диске. Иллюстрация взята из статьи «File Mapping» в MSDN}

Теперь о том, как это применимо к библиотекам и многократно запущенным программам.
Сначала загрузчик просто открывает исполняемый файл. Затем он читает его заголовок и для каждой его секции создаёт отдельное файловое отображение с правами, указанными в заголовке этой секции: для кода, ресурсов, константных данных и изменяемых данных. Причём последнее отображается в режиме Copy-on-Write, чтобы у каждой программы библиотека обладала собственным набором переменных.

Выше я написал упрощённое объяснение, необходимое для понимания концепции. Теперь расскажу о том, как всё это работает на низком уровне.

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

Это возможно благодаря принципам организации работы виртуальной памяти:

^{(Иллюстрация взята из ответа на вопрос «Какую модель памяти сегментную или страничную использует windows, linux, macos?»)}

Именно указатель на начало этого диапазона и возвращают функции MapViewOfFile() на Windows и mmap() на Linux.

Все мы прекрасно знаем, что в операционной системе Windows существуют функции/процедуры, размещаемые внутри динамических библиотек (DLL). Эта особенность является одним из основных отличительных черт современных операционных систем, и Windows тут не исключение.

Динамическая библиотека (DLL) — файл, содержащий исполняемый код (сгруппированный в процедуры/функции) либо данные-ресурсы (шрифты/иконки/иные графические примитивы). Фактически библиотека представляет собой способ разделения общего кода между многими приложениями системы.

Но у библиотек имеется одна характерная особенность: они не запускаются через привычные пользователям механизмы, применимые к исполняемым образам .exe (например, запуск двойным щелчком из проводника), вместо этого процедуры/функции/ресурсы библиотеки доступны для использования исключительно из кода приложений. Одним словом просто так вот щелкнуть в проводнике по .DLL-файлу и запустить его не получится. И все же, у специалиста/пользователя время от времени возникает необходимость воспользоваться функциями той или иной библиотеки, в этом случае имеется два основных пути:

• Написать собственное приложение, которое будет использовать требуемые функции [той или иной библиотеки];
• Воспользоваться специализированным средством (утилитой) командной строки rundll32.exe;

Очевидно, что в рамках данной заметки нам интересен именно второй подход. Для его реализации разработчики из MS создали своеобразный «стартер», который вызывает код [заданной] функции (процедуры), размещаемой в одной из доступных в системе библиотек, прямо из командной строки. Идея была реализована Microsoft в виде утилиты под названием rundll32.exe.
RunDll32 — [системная] утилита командной строки, разработанная для загрузки и запуска функций из 32/64-битных библиотек DLL. Тем не менее, ошибочно было бы считать, что утилита rundll32 является средством для «запуска DLL» по аналогии с исполняемым приложением, в действительности же невозможно «запустить DLL», поскольку это не исполняемый образ в классическом понимании (вроде .EXE-образов).

rundll32 позволяет получить доступ только к функциям/процедурам, которые были описаны надлежащим (определенным) образом: вызываемые функции должны быть экспортируемыми и должны удовлетворять специфичным требованиям к определению входных параметров. Функции библиотек, которые не подпадают по описанные требования, «запускаться» посредством rundll32 не будут.

Теоретически rundll32 может использоваться для запуска функций из любых типов файлов, по структуре идентичных с библиотеками DLL: элементов ActiveX (*.ocx), апплетов панели управления (*.cpl), драйверов (*.drv). Бытует мнение, что когда-то функциональные особенности rundll32 были неявными, то есть «скрытыми» от пользователя системы, но при этом самой системой активно эксплуатирующимися. Не совсем понятное утверждение, поскольку у разработчиков никогда и не существовало проблем в том, чтобы набросать алгоритм запуска произвольных функций библиотек и выделить его в отдельный функционал, к тому же в Windows это основа основ. Со временем утилита rundll32 превратилась в достаточно продвинутое средство, и в определенный момент, по причине того, что программа предоставляла возможности общего характера, разработчики решили включить её в базовый комплект ОС в виде отдельной утилиты. В состав Microsoft Windows 95, Windows 98 и Windows Millennium входили программы rundll.exe и rundll32.exe, а в операционных системах Microsoft Windows NT 4.0, Windows 2000 и Windows XP, в сборку была включена единственная утилита с именем rundll32.exe.

Стоит обратить внимание на то, что в Windows Vista/7 и более поздних ОС, утилита rundll32 не рекомендуется к использованию и включена только лишь с целью сохранения совместимости со старыми сценариями/приложениями.

Причина подобного отношения кроется в многочисленных проблемах, связанных с использованием rundll32 в своих программных окружениях. Как же без rundll32, спросите Вы? Оказывается, Microsoft активно внедряет специализированные системные утилиты, которые постепенно заменяют функционал полюбившегося многим программного средства. Поэтому, время от времени в процессах Windows 7 можно таки встретить процесс rundll32, однако встречается подобное явление всё реже и реже.

Утилита всегда размещается в каталоге %SystemRoot%System32 для 32-битных версий Windows 2000/XP/Vista/7+ и в каталогах %SystemRoot%System32 и %SystemRoot%SysWOW64 для 64-битных версий Windows Vista/7+. В случае обнаружения файла с именем rundll32.exe в любом другом каталоге, настоятельно рекомендуется удалить файл и просканировать станцию на наличие вирусов.

Алгоритм работы rundll32

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

1. Вызывается функция LoadLibrary, которая загружает выбранную DLL;
2. Вызывается функция GetProcAddress, для получения адреса точки входа вызываемой из библиотеки функции;
3. Вызывается проверка соответствия функции специфическим требованиям;
4. Вызывается сама функция и ей передаются входные параметры;
5. Происходит выход из функции по завершению её работы;
6. Библиотека DLL выгружается из памяти процесса.

Как увидеть полный путь запуска rundll32

Если в системе ни с того ни с сего вдруг удалось обнаружить запущенный процесс rundll32, и вам стало интересно, а какой же, собственно, функционал утилита выполняет, то можно определить это по полному пути запуска утилиты rundll32. Посмотреть полный путь запуска, то есть параметры командной строки можно при помощи системной утилиты Диспетчер задач Windows (Task Manager).
Вызовите «Диспетчер задач» (Ctrl+Shift+Esc), перейдите в меню «Вид», выберите пункт «Выбрать столбцы..» и пролистав список вниз, найдите пункт «Командная строка» и отметьте его чекбокс, затем нажмите ОК. Результатом будет появление в главном окне диспетчера задач в параметре «командная строка» полной строки запуска rundll32.

32-битные и 64-битные версии программы

В 64-битных версиях ОС семейства Windows присутствуют 2 варианта программы rundll32.exe:

• 64-битная версия, расположенная в %SystemRoot%System32;
• 32-битная версия, расположенная в %SystemRoot%SysWOW64.

В 64-битной ОС, для загрузки 64-битной библиотеки DLL может быть использована 64-битная версия rundll32.exe, находящаяся в директории %SystemRoot%System32. Напротив, 32-битные программы в 64-битной ОС, обращающиеся к %SystemRoot%System32, в целях обеспечения совместимости будут перенаправлены в %SystemRoot%SysWOW64 и, соответственно, будут использовать уже 32-битную версию rundll32.exe.

Пример использования rundll32

Для запуска программы rundll32 используется синтаксис командной строки следующего вида:

rundll32.exe <имя_библиотеки_dll>,<имя_функции> <необязательные_параметры_функции>

В качестве примера предлагаю разобрать команду запуска апплета «Язык и региональные стандарты» панели управления, вкладка «Форматы»:

rundll32.exe shell32.dll,Control_RunDLL intl.cpl,,0

При выполнении данной команды утилита rundll32 вызовет функцию Control_RunDLL, находящуюся в библиотеке shell32.dll, и передаст ей следующие параметры:

Теперь давайте отметим и некоторые требования к синтаксису rundll32:

• Параметр, описывающий точку входа вызываемой функции (метка EntryPoint) чувствителен к регистру. Это означает, что значение Control_RunDLL не тоже самое что control_rundll. Довольно часто неправильное указание регистра символов вызываемой функции приводит к ошибкам отказа в обнаружении последних.
• Функция (в приведенном выше примере — функция Control_RunDLL) должна самостоятельно выполнять анализ командной строки и идентифицировать отдельные ее аргументы.
• Утилиты rundll/rundll32 ищут указанную библиотеку DLL в стандартных местоположениях.

  В 64-разрядных версиях Windows (начиная с Vista) системные библиотеки размещаются в трёх каталогах: %WinDir%System32, %WinDir%SysWOW64 и %WinDir%WinSxS. Причем последний используется компонентной моделью (Side-by-Side).

  В нашем примере библиотека shell32.dll располагается по известному в переменной %PATH% пути, поэтому мы и указываем её в сокращенном виде. Чтобы быть уверенным, что будет загружена именно интересующая нас библиотека DLL, рекомендуется конкретизировать полный путь к файлу библиотеки. В противном случае может возникнуть ситуация, когда в системе может присутствовать одноименная библиотека, находящаяся в стандартном местоположении (например, по путям, определяемым %PATH%), а та, которую хотите использовать Вы, находится по неизвестному системе пути, в этом случае утилитой rundll32 будет вызвана первая библиотека.

• <имя_библиотеки_dll> не должно содержать недопустимых символов: пробелов, запятых и кавычек (ограничение это накладывается кодом анализатора командной строки утилиты rundll32).
  Ранее, во времена Windows 95/98, к синтаксису командной строки утилиты rundll32 применялись достаточно жесткие требования. Например, чрезвычайно важным являлось наличие запятой («,») между параметром <имя_библиотеки_dll> и именем вызываемой функции. Если запятая опускалась, утилита rundll32 «по-тихому» завершала работу, не выполняя никаких действий с библиотекой. Кроме того, между параметром <имя_библиотеки_dll>, символом запятой и названием вызываемой функции не должно было быть никаких пробелов. Но, со временем анализатор командной строки утилиты претерпевал изменения и эволюционировал, и в данный момент, синтаксис rundll32 позволяет применять пробел между именем библиотеки и именем функции.

Правила создания функций

Очевидно, что в создаваемую нами собственную библиотеку DLL необходимо поместить функцию со следующими входными параметрами (пример описания на Ассемблере):

При создании экспортируемой функции (в примерах выше она имеет псевдо-имя EntryPoint) необходимо учитывать следующие моменты:

1. Вместо имени EntryPoint, желательно указать фактическое имя функции. Обратите внимание, что «точка входа», используемая программой rundll32, не зависит от функции (точки входа) DllEntryPoint, которая в 32-разрядных библиотеках DLL осуществляет обработку процессов и оповещение о подключении и отключении потоков. Это точка входа в саму функцию.
2. Функцию, являющуюся точкой входа для программы rundll32, необходимо определить, используя соглашение о вызовах _stdcall (в C++ по умолчанию для атрибута _stdcall используется значение CALLBACK). Иначе, по умолчанию будет использоваться другое соглашение о вызовах _cdecl. Это приведет к аварийному завершению работы программы rundll32 после вызова данной функции.

Функции, являющейся точкой входа, передаются следующие параметры:

Пример создания DLL с экспортируемой функцией

Я написал код примера на языке Ассемблера, уж не обессудьте, поскольку пока лишь на этом языке я хоть как-то могу внятно выражать свои мысли Компилируется исходный код посредством компилятора FASM, версией для Windows (FASMW.EXE). В библиотеке я описал одну единственную экспортируемую функцию под названием ShowErrorMessage, которая выводит на экран окно ошибки с заданными параметрами. Создадим файл testdll.asm и добавим в него следующее содержимое:

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

rundll32 testdll.dll,ShowErrorMessage ThisIsTestString

предисловие

Процессы — это программы, которые загружаются в память и готовы к выполнению. Каждый процесс имеет личное виртуальное адресное пространство, состоящее из кода, данных и других ресурсов. 32-разрядные системные процессы выделяют 4G виртуального адресного пространства. Диапазон адресов памяти составляет 0x00000000 ～ 0xFFFFFFFF. Это адресное пространство памяти является независимым для каждого процесса, то есть один процесс не может получить доступ к адресному пространству других процессов.

Например, часть данных сохраняется в памяти процесса A. Предположим, что адрес этих данных равен 0x33333333. Это время, даже если считываются данные адреса памяти процесса B 0x33333333. Эти данные также отличаются от данных по тому же адресу в процессе А. Даже адрес 0x33333333 процесса B вообще не имеет данных.

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

Способ реализовать

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

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

+———————————+ 4 GB

|                  |

| Пространство ядра |

|                  |
|    　　　　　　　　　　　　  |
+———————————+ 3 GB
|                  |
| Общее пространство пользователя |
|                 |
|                 |
+———————————+ 2 GB
|                 |
| Личное пространство пользователя |
|                 |
|                  |
+———————————+ 0 GB

Из этого рисунка видно, что все упомянутые выше вызовы DLL используют 0–2 ГБ виртуального пространства. Если вы хотите добиться совместного использования, вы можете использовать пространство 2GB-3GB. Другими словами, данные должны быть сохранены в этом пространстве. Здесь нам нужно использовать #pragma data_seg () для определения общего именованного сегмента данных в DLL. Конкретно, как этого добиться, мы можем продемонстрировать на следующем примере.

Демо пример

Сначала создайте совместный проект DLL, эта DLL используется для сохранения общих данных.

Этапы реализации

1. Создайте новый проект Win32 и назовите его SharedDll

2. DLL выбора типа программы

3. Инженерная структура

4. Файл SharedDll.h в основном объявляет, что две функции используются для сохранения общих данных и получения общих данных.

// The following ifdef block is the standard way of creating macros which make exporting   
// from a DLL simpler. All files within this DLL are compiled with the SHAREDDLL_EXPORTS  
// symbol defined on the command line. this symbol should not be defined on any project  
// that uses this DLL. This way any other project whose source files include this file see   
// SHAREDDLL_API functions as being imported from a DLL, whereas this DLL sees symbols  
// defined with this macro as being exported.  
#ifdef SHAREDDLL_EXPORTS  
#define SHAREDDLL_API __declspec(dllexport)  
#else  
#define SHAREDDLL_API __declspec(dllimport)  
#endif  
  
// This class is exported from the SharedDll.dll  
class SHAREDDLL_API CSharedDll {  
public:  
    CSharedDll(void);  
    // TODO: add your methods here.  
};  
  
// set string to shared dll  
SHAREDDLL_API void SetValueString(LPCSTR str);  
  
// get string from shared dll  
SHAREDDLL_API LPSTR GetValueString();  

5. В файле SharedDll.cpp используйте команду предварительной обработки #pragma data_seg для установки сегмента общих данных.

……  
 // Объявление общих данных начинается  
#pragma data_seg("SharedData")   
 // Обязательно инициализируйте следующие переменные, иначе данные не будут разделены между несколькими процессами  
char m_strString[256]="";   
 // Конец объявления общих данных       
#pragma data_seg()  
 // Разрешение на определение общего сегмента данных в соединителе доступно для чтения, записи и совместного использования  
#pragma comment(linker,"/SECTION:SharedData,RWS")  
  
 // Интерфейс для получения общих данных  
SHAREDDLL_API LPSTR GetValueString()  
{  
    return m_strString;  
}  
 // Сохранить интерфейс обмена данными  
SHAREDDLL_API  void SetValueString(LPCSTR str)  
{  
    strcpy(m_strString,str);  
}  
……  
 

Пока что проект совместного использования DLL готов. Затем создайте два приложения MFC для сохранения данных в общей библиотеке DLL или получения данных из общей библиотеки DLL.

Первая программа: Создайте программу MCF Dialog, экран выглядит следующим образом. Поле ввода используется для ввода информации о данных, а кнопка [Отправить] используется для отправки данных в общую DLL. Конечно, проект должен импортировать пакет lib из SharedDLL.

Код реализации выглядит следующим образом:

……  
 // [Submit] событие нажатия кнопки  
void CFormADlg::OnBnClickedOk()  
{  
         // Получить информацию о входных данных из окна редактирования  
    CEdit* e = (CEdit*) this->GetDlgItem(IDC_EDIT1);  
    CString str;  
    e->GetWindowText(str);  
               // Вызов интерфейса SetValueString файла SharedDLL.dll для сохранения данных в общей DLL  
    SetValueString((LPCTSTR)str);  
}  
……  
 

Вторая программа: как описано выше, создайте новую программу MCF Dialog, экран выглядит следующим образом. Поле редактирования используется для отображения информации о данных, а кнопка [Отображение] используется для получения данных, сохраненных в общей DLL. Этот проект также должен импортировать пакет SharedDLL lib.

код шоу, как показано ниже:

……  
// [Display] событие нажатия кнопки  
void CFormBDlg::OnBnClickedOk()  
{  
         // Вызвать интерфейс GetValueString SharedDLL.dll для получения общих данных  
    CString str = (CString)GetValueString();  
                 // Вывод полученных данных в поле редактирования формы FormB  
    CEdit* e = (CEdit*) this->GetDlgItem(IDC_EDIT1);  
    e->SetWindowText(str);  
}  

Таким образом, все проекты были завершены, давайте посмотрим на результаты работы.

Сначала мы копируем SharedDll.dll, FormA.exe и FormB.exe в один каталог, чтобы облегчить их взаимный доступ.

Затем запустите две программы, FormA.exe и FormB.exe.

Введите данные в поле редактирования окна FormA и нажмите кнопку «Отправить».

Затем нажмите кнопку Показать в окне FormB

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

20.07.2010, 23:49. Показов 112646. Ответов 7

call адрес_вызываемой_процедуры

1
2
3
4
5
6
7

;Произвольный код
call 010199  ; Вызов процедуры
; Произвольный код
; Код с адреса 010199:
add eax, 500
mul eax, edx
ret

1

int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void* lpReserved);

1

BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fwdreason, LPVOID lpvReserved);

1
2
3
4
5
6
7

#include "TestDLL.h" // создание этого заголовочного файла будет описано ниже
//---------------------------------------------------------------------------
void ShowSum(const int A, const int B)
{
  ShowMessage(IntToStr(A) + " + " + IntToStr(B) + " = " + IntToStr(A + B));
}
//---------------------------------------------------------------------------

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#ifndef __TESTDLL_H
#define __TESTDLL_H
 
/*
символ TESTDLL_EXPORTS по умолчанию определен в Вашем проекте (см. Project Options -> С/С++ -> General->Preprocessor Definitions).
При этом все экспортируемые идентификаторы предваряются символом DLL_SPEC.
В случае определения TESTDLL_EXPORTS в проекте DLL_SPEC определяется как экспортируемый объект; в случае же отсутствия такого определения мы получим импортируемый объект.
Таким образом, один и тот же заголовочный файл может быть использован и в DLL-проекте, и в проекте, который будет использовать данную DLL! Без каких-либо изменений.
*/
 
#ifdef TESTDLL_EXPORTS
#define DLL_SPEC extern "C" __declspec(dllexport)
 
#else
#define DLL_SPEC extern "C" __declspec(dllimport)
#endif // TESTDLL_EXPORTS
 
/*
Каждый экспортируемый идентификатор предваряем __declspec(dllexport).
Эта директива позволяет линкеру определить, что данный идентификатор следует экспортировать из DLL. При этом создается специальный lib-файл, который содержит все экспортируемые идентификаторы из модуля. Также экспортируемые объекты заносятся в раздел экспорта DLL.
*/
 
DLL_SPEC void ShowSum(const int A, const int B);
 
#endif // __TESTDLL_H

1

#include "TestDLL.h"

1

void DLL_SPEC ShowSum(const int A, const int B);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// определяем тип "указатель на функцию"
typedef void __cdecl (*dll_func)(const int A, const int B);
 
dll_func pShowSum = NULL;
 
HMODULE hDLL = LoadLibrary("TestDLL.dll");
if (!hDLL) {
  ShowMessage("Невозможно загрузить TestDLL.dll");
  return;
}
 
// пытаемся найти в таблице экспорта необходимую нам функцию
pShowSum = (dll_func)GetProcAddress(hDLL, "_ShowSum"); // обратите внимание на название функции (объяснение будет ниже)
 
if (!pShowSum) {
  ShowMessage("Невозможно найти функцию ShowSum");
  return;
}
 
pShowSum(3,2);
 
FreeLibrary(hDLL);

58

С самого рождения (или чуть позже) операционная система Windows использовала библиотеки динамической компоновки DLL (Dynamic Link Library), в которых содержались реализации наиболее часто применяемых функций. Наследники Windows — NT и Windows 95, а также OS/2 — тоже зависят от библиотек DLL в плане обеспечения значительной части их функциональных возможностей.

Рассмотрим ряд аспектов создания и использования библиотек DLL:

• как статически подключать библиотеки DLL;
• как динамически загружать библиотеки DLL;
• как создавать библиотеки DLL;
• как создавать расширения МFC библиотек DLL.

Использование DLL

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

Вообще говоря, DLL — это просто наборы функций, собранные в библиотеки. Однако, в отличие от своих статических родственников (файлов . lib), библиотеки DLL не присоединены непосредственно к выполняемым файлам с помощью редактора связей. В выполняемый файл занесена только информация об их местонахождении. В момент выполнения программы загружается вся библиотека целиком. Благодаря этому разные процессы могут пользоваться совместно одними и теми же библиотеками, находящимися в памяти. Такой подход позволяет сократить объем памяти, необходимый для нескольких приложений, использующих много общих библиотек, а также контролировать размеры ЕХЕ-файлов.

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

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

Библиотеки импортирования

При статическом подключении DLL имя .lib-файла определяется среди прочих параметров редактора связей в командной строке или на вкладке «Link» диалогового окна «Project Settings» среды Developer Studio. Однако .lib-файл, используемый при неявном подключении DLL, — это не обычная статическая библиотека. Такие .lib-файлы называются библиотеками импортирования (import libraries). В них содержится не сам код библиотеки, а только ссылки на все функции, экспортируемые из файла DLL, в котором все и хранится. В результате библиотеки импортирования, как правило, имеют меньший размер, чем DLL-файлы. К способам их создания вернемся позднее. А сейчас рассмотрим другие вопросы, касающиеся неявного подключения динамических библиотек.

Согласование интерфейсов

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

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

По умолчанию в Visual C++ интерфейсы функций согласуются по правилам C++. Это значит, что параметры заносятся в стек справа налево, вызывающая программа отвечает за их удаление из стека при выходе из функции и расширении ее имени. Расширение имен (name mangling) позволяет редактору связей различать перегруженные функции, т.е. функции с одинаковыми именами, но разными списками аргументов. Однако в старой библиотеке С функции с расширенными именами отсутствуют.

Хотя все остальные правила вызова функции в С идентичны правилам вызова функции в C++, в библиотеках С имена функций не расширяются. К ним только добавляется впереди символ подчеркивания (_).

Если необходимо подключить библиотеку на С к приложению на C++, все функции из этой библиотеки придется объявить как внешние в формате С:

    extern     "С" int MyOldCFunction(int myParam);

Объявления функций библиотеки обычно помещаются в файле заголовка этой библиотеки, хотя заголовки большинства библиотек С не рассчитаны на применение в проектах на C++. В этом случае необходимо создать копию файла заголовка и включить в нее модификатор extern «C» к объявлению всех используемых функций библиотеки. Модификатор extern «C» можно применить и к целому блоку, к которому с помощью директивы #tinclude подключен файл старого заголовка С. Таким образом, вместо модификации каждой функции в отдельности можно обойтись всего тремя строками:

    extern     "С" 
    {
        #include "MyCLib.h"
    }

В программах для старых версий Windows использовались также соглашения о вызове функций языка PASCAL для функций Windows API. В новых программах следует использовать модификатор winapi, преобразуемый в _stdcall. Хотя это и не стандартный интерфейс функций С или C++, но именно он используется для обращений к функциям Windows API. Однако обычно все это уже учтено в стандартных заголовках Windows.

Загрузка неявно подключаемой DLL

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

• Каталог, в котором находится ЕХЕ-файл.
• Текущий каталог процесса.
• Системный каталог Windows.

Если библиотека DLL не обнаружена, приложение выводит диалоговое окно с сообщением о ее отсутствии и путях, по которым осуществлялся поиск. Затем процесс отключается.

Если нужная библиотека найдена, она помещается в оперативную память процесса, где и остается до его окончания. Теперь приложение может обращаться к функциям, содержащимся в DLL.

Динамическая загрузка и выгрузка DLL

Вместо того, чтобы Windows выполняла динамическое связывание с DLL при первой загрузке приложения в оперативную память, можно связать программу с модулем библиотеки во время выполнения программы (при таком способе в процессе создания приложения не нужно использовать библиотеку импорта). В частности, можно определить, какая из библиотек DLL доступна пользователю, или разрешить пользователю выбрать, какая из библиотек будет загружаться. Таким образом можно использовать разные DLL, в которых реализованы одни и те же функции, выполняющие различные действия. Например, приложение, предназначенное для независимой передачи данных, сможет в ходе выполнения принять решение, загружать ли DLL для протокола TCP/IP или для другого протокола.

Загрузка обычной DLL

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

    HINSTANCE hMyDll;
    ::
    if((hMyDll=::    LoadLibrary("MyDLL"))==NULL) { /* не удалось загрузить DLL */ }
    else { /* приложение имеет право пользоваться функциями DLL через hMyDll */ }

Стандартным расширением файла библиотеки Windows считает .dll, если не указать другое расширение. Если в имени файла указан и путь, то только он будет использоваться для поиска файла. В противном случае Windows будет искать файл по той же схеме, что и в случае неявно подключенных DLL, начиная с каталога, из которого загружается exe-файл, и продолжая в соответствии со значением PATH.

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

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

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

        // тип PFN_MyFunction будет объявлять указатель на функцию, 
    // принимающую указатель на символьный буфер и выдающую значение типа int
    typedef int (WINAPI *PFN_MyFunction)(char *);
    ::
    PFN_MyFunction pfnMyFunction;

Затем следует получить дескриптор библиотеки, при помощи которого и определить адреса функций, например адрес функции с именем MyFunction:

    hMyDll=::LoadLibrary("MyDLL");
    pfnMyFunction=(PFN_MyFunction)::GetProcAddress(hMyDll,"MyFunction");
    ::
    int iCode=(*pfnMyFunction)("Hello");

Адрес функции определяется при помощи функции ::GetProcAddress, ей следует передать имя библиотеки и имя функции. Последнее должно передаваться в том виде, в котором экспортируется из DLL.

Можно также сослаться на функцию по порядковому номеру, по которому она экспортируется (при этом для создания библиотеки должен использоваться def-файл, об этом будет рассказано далее):

    pfnMyFunction=(PFN_MyFunction)::GetProcAddress(hMyDll,
                MAKEINTRESOURCE(1));

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

    ::FreeLibrary(hMyDll);

Загрузка MFC-расширений динамических библиотек

При загрузке MFC-расширений для DLL (подробно о которых рассказывается далее) вместо функций LoadLibraryи FreeLibrary используются функции AfxLoadLibrary и AfxFreeLibrary. Последние почти идентичны функциям Win32 API. Они лишь гарантируют дополнительно, что структуры MFC, инициализированные расширением DLL, не были запорчены другими потоками.

Ресурсы DLL

Динамическая загрузка применима и к ресурсам DLL, используемым MFC для загрузки стандартных ресурсов приложения. Для этого сначала необходимо вызвать функцию LoadLibrary и разместить DLL в памяти. Затем с помощью функции AfxSetResourceHandle нужно подготовить окно программы к приему ресурсов из вновь загруженной библиотеки. В противном случае ресурсы будут загружаться из файлов, подключенных к выполняемому файлу процесса. Такой подход удобен, если нужно использовать различные наборы ресурсов, например для разных языков.

Замечание. С помощью функции LoadLibrary можно также загружать в память исполняемые файлы (не запускать их на выполнение!). Дескриптор выполняемого модуля может затем использоваться при обращении к функциям FindResource и LoadResource для поиска и загрузки ресурсов приложения. Выгружают модули из памяти также при помощи функции FreeLibrary.

Пример обычной DLL и способов загрузки

Приведем исходный код динамически подключаемой библиотеки, которая называется MyDLL и содержит одну функцию MyFunction, которая просто выводит сообщение.

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

MyDLL.h
    #define EXPORT extern "C" __declspec (dllexport)
    EXPORT int CALLBACK MyFunction(char *str);

Файл библиотеки также несколько отличается от обычных файлов на языке C для Windows. В нем вместо функции WinMain имеется функция DllMain. Эта функция используется для выполнения инициализации, о чем будет рассказано позже. Для того, чтобы библиотека осталась после ее загрузки в памяти, и можно было вызывать ее функции, необходимо, чтобы ее возвращаемым значением было TRUE:

MyDLL.c
    #include <windows.h>
    #include "MyDLL.h"

    int WINAPI DllMain(HINSTANCE hInstance, DWORD fdReason, PVOID pvReserved)
    {
        return TRUE;
    }
    EXPORT int CALLBACK MyFunction(char *str)
    {
        MessageBox(NULL,str,"Function from DLL",MB_OK);
        return 1;
    }

После трансляции и компоновки этих файлов появляется два файла — MyDLL.dll (сама динамически подключаемая библиотека) и MyDLL.lib (ее библиотека импорта).

Пример неявного подключения DLL приложением

Приведем теперь исходный код простого приложения, которое использует функцию MyFunction из библиотеки MyDLL.dll:

    #include <windows.h>
    #include "MyDLL.h"

    int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
            LPSTR lpCmdLine, int nCmdShow)
    {
        int iCode=MyFunction("Hello");
        return 0;
    }

Эта программа выглядит как обычная программ для Windows, чем она в сущности и является. Тем не менее, следует обратить внимание, что в исходный ее текст помимо вызова функции MyFunction из DLL-библиотеки включен и заголовочный файл этой библиотеки MyDLL.h. Также необходимо на этапе компоновки приложения подключить к нему библиотеку импорта MyDLL.lib (процесс неявного подключения DLL к исполняемому модулю).

Чрезвычайно важно понимать, что сам код функции MyFunction не включается в файл MyApp.exe. Вместо этого там просто имеется ссылка на файл MyDLL.dll и ссылка на функцию MyFunction, которая находится в этом файле. Файл MyApp.exe требует запуска файла MyDLL.dll.

Заголовочный файл MyDLL.h включен в файл с исходным текстом программы MyApp.c точно так же, как туда включен файл windows.h. Включение библиотеки импорта MyDLL.lib для компоновки аналогично включению туда всех библиотек импорта Windows. Когда программа MyApp.exe работает, она подключается к библиотеке MyDLL.dll точно так же, как ко всем стандартным динамически подключаемым библиотекам Windows.

Пример динамической загрузки DLL приложением

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

    #include <windows.h>
    typedef int (WINAPI *PFN_MyFunction)(char *);

    int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
            LPSTR lpCmdLine, int nCmdShow)
    {
        HINSTANCE hMyDll;
        if((hMyDll=LoadLibrary("MyDLL"))==NULL) return 1;

        PFN_MyFunction pfnMyFunction;
        pfnMyFunction=(PFN_MyFunction)GetProcAddress(hMyDll,"MyFunction");
        int iCode=(*pfnMyFunction)("Hello");

        FreeLibrary(hMyDll);
        return 0;
    }

Создание DLL

Теперь, познакомившись с принципами работы библиотек DLL в приложениях, рассмотрим способы их создания. При разработке приложении функции, к которым обращается несколько процессов, желательно размещать в DLL. Это позволяет более рационально использовать память в Windows.

Проще всего создать новый проект DLL с помощью мастера AppWizard, который автоматически выполняет многие операции. Для простых DLL, таких как рассмотренные в этой главе, необходимо выбрать тип проекта Win32 Dynamic-Link Library. Новому проекту будут присвоены все необходимые параметры для создания библиотеки DLL. Файлы исходных текстов придется добавлять к проекту вручную.

Если же планируется в полной мере использовать функциональные возможности MFC, такие как документы и представления, или намерены создать сервер автоматизации OLE, лучше выбрать тип проекта MFC AppWizard (dll). В этом случае, помимо присвоения проекту параметров для подключения динамических библиотек, мастер проделает некоторую дополнительную работу. В проект будут добавлены необходимые ссылки на библиотеки MFC и файлы исходных текстов, содержащие описание и реализацию в библиотеке DLL объекта класса приложения, производного от CWinApp.

Иногда удобно сначала создать проект типа MFC AppWizard (dll) в качестве тестового приложения, а затем — библиотеку DLL в виде его составной части. В результате DLL в случае необходимости будет создаваться автоматически.

Функция DllMain

Большинство библиотек DLL — просто коллекции практически независимых друг от друга функций, экспортируемых в приложения и используемых в них. Кроме функций, предназначенных для экспортирования, в каждой библиотеке DLL есть функция DllMain. Эта функция предназначена для инициализации и очистки DLL. Она пришла на смену функциям LibMain и WEP, применявшимся в предыдущих версиях Windows. Структура простейшей функции DllMain может выглядеть, например, так:

    BOOL WINAPI DllMain (HANDLE hInst,DWORD dwReason, LPVOID IpReserved)
    {
        BOOL bAllWentWell=TRUE;
        switch (dwReason) 
        {
            case DLL_PROCESS_ATTACH:     // Инициализация процесса. 
                break;
            case DLL_THREAD_ATTACH:     // Инициализация потока.
                break;
            case DLL_THREAD_DETACH:     // Очистка структур потока.
                break;
            case DLL_PROCESS_DETACH:     // Очистка структур процесса.
                break;
        }
        if(bAllWentWell)     return TRUE;
        else            return FALSE;
    }

Функция DllMain вызывается в нескольких случаях. Причина ее вызова определяется параметром dwReason, который может принимать одно из следующих значений.

При первой загрузке библиотеки DLL процессом вызывается функция DllMain с dwReason, равным DLL_PROCESS_ATTACH. Каждый раз при создании процессом нового потока DllMainO вызывается с dwReason, равным DLL_THREAD_ATTACH (кроме первого потока, потому что в этом случае dwReason равен DLL_PROCESS_ATTACH).

По окончании работы процесса с DLL функция DllMain вызывается с параметром dwReason, равным DLL_PROCESS_DETACH. При уничтожении потока (кроме первого) dwReason будет равен DLL_THREAD_DETACH.

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

В состав DLL могут входить ресурсы, не принадлежащие вызывающему эту библиотеку приложению. Если функции DLL работают с ресурсами DLL, было бы, очевидно, полезно сохранить где-нибудь в укромном месте дескриптор hInst и использовать его при загрузке ресурсов из DLL. Указатель IpReserved зарезервирован для внутреннего использования Windows. Следовательно, приложение не должно претендовать на него. Можно лишь проверить его значение. Если библиотека DLL была загружена динамически, оно будет равно NULL. При статической загрузке этот указатель будет ненулевым.

В случае успешного завершения функция DllMain должна возвращать TRUE. В случае возникновения ошибки возвращается FALSE, и дальнейшие действия прекращаются.

Замечание. Если не написать собственной функции DllMain(), компилятор подключит стандартную версию, которая просто возвращает TRUE.

Экспортирование функций из DLL

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

Метод __declspec (dllexport)

Можно экспортировать функцию из DLL, поставив в начале ее описания модификатор __declspec (dllexport) . Кроме того, в состав MFC входит несколько макросов, определяющих __declspec (dllexport), в том числе AFX_CLASS_EXPORT, AFX_DATA_EXPORT и AFX_API_EXPORT.

Метод __declspec применяется не так часто, как второй метод, работающий с файлами определения модуля (.def), и позволяет лучше управлять процессом экспортирования.

Файлы определения модуля

Синтаксис файлов с расширением .def в Visual C++ достаточно прямолинеен, главным образом потому, что сложные параметры, использовавшиеся в ранних версиях Windows, в Win32 более не применяются. Как станет ясно из следующего простого примера, .def-файл содержит имя и описание библиотеки, а также список экспортируемых функций:

MyDLL.def
    LIBRARY         "MyDLL"
        DESCRIPTION    'MyDLL - пример DLL-библиотеки'

    EXPORTS
        MyFunction     @1

В строке экспорта функции можно указать ее порядковый номер, поставив перед ним символ @. Этот номер будет затем использоваться при обращении к GetProcAddress (). На самом деле компилятор присваивает порядковые номера всем экспортируемым объектам. Однако способ, которым он это делает, отчасти непредсказуем, если не присвоить эти номера явно.

В строке экспорта можно использовать параметр NONAME. Он запрещает компилятору включать имя функции в таблицу экспортирования DLL:

        MyFunction     @1 NONAME

Иногда это позволяет сэкономить много места в файле DLL. Приложения, использующие библиотеку импортирования для неявного подключения DLL, не «заметят» разницы, поскольку при неявном подключении порядковые номера используются автоматически. Приложениям, загружающим библиотеки DLL динамически, потребуется передавать в GetProcAddress порядковый номер, а не имя функции.

При использовании вышеприведенного def-файл описания экспортируемых функций DLL-библиотеки может быть,например, не таким:

    #define EXPORT extern "C" __declspec (dllexport)
    EXPORT int CALLBACK MyFunction(char *str);
    a таким:
    extern "C" int CALLBACK MyFunction(char *str);

Экспортирование классов

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

Если взглянуть на реализованный в классе файл распределения памяти, в нем можно заметить некоторые весьма необычные функции. Оказывается, здесь есть неявные конструкторы и деструкторы, функции, объявленные в макросах MFC, в частности _DECLARE_MESSAGE_MAP, а также функции, которые написанные программистом.

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

Память DLL

В отличие от статических библиотек, которые, по существу, становятся частью кода приложения, библиотеки динамической компоновки в 16-разрядных версиях Windows работали с памятью несколько иначе. Под управлением Win 16 память DLL размещалась вне адресного пространства задачи. Размещение динамических библиотек в глобальной памяти обеспечивало возможность совместного использования их различными задачами.

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

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

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

    #pragma data_seg(".myseg")
    int sharedlnts[10] ;
        // другие переменные общего пользования
    #pragma data_seg()
    #pragma comment(lib, "msvcrt" "-SECTION:.myseg,rws");

Все переменные, объявленные между директивами #pragma data_seg(), размещаются в сегменте .myseg. Директива #pragma comment () — не обычный комментарий. Она дает указание библиотеке выполняющей системы С пометить новый раздел как разрешенный для чтения, записи и совместного доступа.

Полная компиляция DLL

Если проект динамической библиотеки создан с помощью AppWizard и .def-файл модифицирован соответствующим образом — этого достаточно. Если же файлы проекта создаются вручную или другими способами без помощи AppWizard, в командную строку редактора связей следует включить параметр /DLL. В результате вместо автономного выполняемого файла будет создана библиотека DLL.

Если в .def-файле есть строка LIBRART, указывать явно параметр /DLL в командной строке редактора связей не нужно.

Для MFC предусмотрен ряд особых режимов, касающихся использования динамической библиотекой библиотек MFC. Этому вопросу посвящен следующий раздел.

DLL и MFC

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

Имеется два уровня использования структуры MFC в DLL. Первый из них — это обычная динамическая библиотека на основе MFC, MFC DLL (regular MFC DLL). Она может использовать MFC, но не может передавать указатели на объекты MFC между DLL и приложениями. Второй уровень реализован в динамических расширениях MFC (MFC extensions DLL). Использование этого вида динамических библиотек требует некоторых дополнительных усилий по настройке, но позволяет свободно обмениваться указателями на объекты MFC между DLL и приложением.

Обычные MFC DLL

Обычные MFC DLL позволяют применять MFC в динамических библиотеках. При этом приложения, обращающиеся к таким библиотекам, не обязательно должны быть построены на основе MFC. В обычных DLL можно использовать MFC любым способом, в том числе создавая в DLL новые классы на базе классов MFC и экспортируя их в приложения.

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

Если приложению необходимо обмениваться с DLL указателями на объекты классов MFC или их производных, нужно использовать расширение DLL, описанное в следующем разделе.

Архитектура обычных DLL рассчитана на использование другими средами программирования, такими как Visual Basic и PowerBuilder.

При создании обычной библиотеки MFC DLL с помощью AppWizard выбирается новый проект типа MFC AppWizard (dll). В первом диалоговом окне мастера приложений необходимо выбрать один из режимов для обычных динамических библиотек: «Regular DLL with MFC statistically linked» или «Regular DLL using shared MFC DLL». Первый предусматривает статическое, а второй — динамическое подключение библиотек MFC. Впоследствии режим подключения MFC к DLL можно будет изменить с помощью комбинированного списка на вкладке «General» диалогового окна «Project settings».

Управление информацией о состоянии MFC

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

    AFX_MANAGE_STATE(AfxGetStaticModuleState()) ;

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

Динамические расширения MFC

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

Чтобы обеспечить возможность свободного обмена указателями на объекты MFC между приложением и DLL, нужно создать динамическое расширение MFC. DLL этого типа подключаются к динамическим библиотекам MFC так же, как и любые приложения, использующие динамическое расширение MFC.

Чтобы создать новое динамическое расширение MFC, проще всего, воспользовавшись мастером приложении, присвоить проекту тип MFC AppWizard (dll) и на шаге 1 включить режим «MFC Extension DLL». В результате новому проекту будут присвоены все необходимые атрибуты динамического расширения MFC. Кроме того, будет создана функция DllMain для DLL, выполняющая ряд специфических операций по инициализации расширения DLL. Следует обратить внимание, что динамические библиотеки данного типа не содержат и не должны содержать объектов, производных от CWinApp.

Инициализация динамических расширений

Чтобы «вписаться» в структуру MFC, динамические расширения MFC требуют дополнительной начальной настройки. Соответствующие операции выполняются функцией DllMain. Рассмотрим пример этой функции, созданный мастером AppWizard.

    static AFX_EXTENSION_MODULE MyExtDLL = { NULL, NULL } ;
    extern "C" int APIENTRY
    DllMain(HINSTANCE hinstance, DWORD dwReason, LPVOID IpReserved)
    {
        if (dwReason == DLL_PROCESS_ATTACH)
        {
            TRACED("MYEXT.DLL Initializing!n") ;
            // Extension DLL one-time initialization
            AfxInitExtensionModule(MyExtDLL, hinstance) ;

            // Insert this DLL into the resource chain
            new CDynLinkLibrary(MyExtDLL);
        }
        else if (dwReason == DLL_PROCESS_DETACH)
        {
            TRACED("MYEXT.DLL Terminating!n") ;
        }
        return 1; // ok
    }

Самой важной частью этой функции является вызов AfxInitExtensionModule. Это инициализация динамической библиотеки, позволяющая ей корректно работать в составе структуры MFC. Аргументами данной функции являются передаваемый в DllMain дескриптор библиотеки DLL и структура AFX_EXTENSION_MODULE, содержащая информацию о подключаемой к MFC динамической библиотеке.

Нет необходимости инициализировать структуру AFX_EXTENSION_MODULE явно. Однако объявить ее нужно обязательно. Инициализацией же займется конструктор CDynLinkLibrary. В DLL необходимо создать класс CDynLinkLibrary. Его конструктор не только будет инициализировать структуру AFX_EXTENSION_MODULE, но и добавит новую библиотеку в список DLL, с которыми может работать MFC.

Загрузка динамических расширений MFC

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

    if(dwReason == DLL_PROCESS_DETACH) 
    {
        AfxTermExtensionModule(MyExtDLL);
    }

Кроме того, следует помнить, что новая библиотека DLL является динамическим расширением и должна загружаться и выгружаться динамически, с помощью функций AfxLoadLibrary и AfxFreeLibrary,а не LoadLibrary и FreeLibrary.

Экспортирование функций из динамических расширений

Рассмотрим теперь, как осуществляется экспортирование в приложение функций и классов из динамического расширения. Хотя добавить в DEF-файл все расширенные имена можно и вручную, лучше использовать модификаторы для объявлений экспортируемых классов и функций, такие как AFX_EXT_CLASS и AFX_EXT_API,например:

    class AFX_EXT_CLASS CMyClass : public CObject
    (
        // Your class declaration
    }
    void AFX_EXT_API MyFunc() ;