動態連接庫（Dynamic Link Library）

時間 2019-11-09

標籤動態連接 dynamic link library 简体版

原文原文鏈接

DLL INTRODUCTION

A DLL is a library that contains code and data that can be used by more than one program at the same time. For example, in Windows operating systems, the Comdlg32 DLL performs common dialog box related functions. Therefore, each program can use the functionality that is contained in this DLL to implement an Open dialog box. This helps promote code reuse and efficient memory usage.
By using a DLL, a program can be modularized into separate components. For example, an accounting program may be sold by module. Each module can be loaded into the main program at run time if that module is installed. Because the modules are separate, the load time of the program is faster, and a module is only loaded when that functionality is requested.
Additionally, updates are easier to apply to each module without affecting other parts of the program. For example, you may have a payroll program, and the tax rates change each year. When these changes are isolated to a DLL, you can apply an update without needing to build or install the whole program again.app

DLL development
This section describes the issues and the requirements that you should consider when you develop your own DLLs.
Types of DLLS
- When you load a DLL in an application,two methods of linking let you call the exported DLL functions. The two methods of linking are load-time dynamic linking and run-time dynamic linking.
- Load-time dynamic linking
  - In load-time dynamic linking, an application makes explicit calls to exported DLL functions like local functions. To use load-time dynamic linking, provide a header (.h) file and an import library (.lib) file when you compile and link the application. When you do this, the linker will provide the system with the information that is requred to load the DLL and resolve the exported DLL function locations at load time.
- Run-time dyanmic linking:
  - In run-time dynamic linking, an application calls either the LoadLibrary function or the LoadLibraryEx function to load the DLL at run time. After the DLL is successfully loaded, you use the GetProcAddress function to obtain the address of the exported DLL function that you want to call. When you use run-time dynamic linking, you do not need an import libraty file.
- The following list describes the application criteria for when to use load-time dynamic linking and when to use run-time dynamic linking:
  - Startup performance
    - If the initial startup performance of the application is important, you should use run-time dynamic linking.
  - Ease of use
    - In load-time dynamic linking, the exported DLL functions are like local functions. This makes it easy for you to call these functions.
  - Application logic
    - In run-time dynamic linking, an application can branch to load different modules as required. This is important when you develop multiple-language versions.
The DLL entry point
- When you create a DLL, you can optionally specify an entry point function. The entry point function is called when proccess or threads attach themselves to the DLL or detached themselves from the DLL. You can use the entry point function to initialize data structure or to destory data structure as required by the DLL. Additionally, if the application is multithreaded, you can use thread local storage to allocate memory that is private to each thread the entry point function.The following code is an example of the DLL entry point function.
- ```
BOOL APIENTRY DllMain(
      HANDLE hModule,// Handle to DLL module
      DWORD ul_reason_for_call,// Reason for calling function
      LPVOID lpReserved ) // Reserved
      {
          switch ( ul_reason_for_call )
          {
          case DLL_THREAD_ATTACH:
              // A process is loading the DLL.
              break;
          case DLL_THREAD_DETACH:
              // A process is creating a new thread.
              break;
          case DLL_PROCESS_ATTACH:
              // A thread exits normally.
              break;
          case DLL_PROCESS_DETACH:
              // A process unloads the DLL.
              break;
          }
          return TRUE;
      }
```
- When the entry point function returns a FALSE value, the application will not start if you are using load-time dynamic linking. If you are using run-time dynamic linking, only the individual DLL will not load.
- The entry point function should only perform simple initialization tasks and should not call any other DLL loading or termination functions. For example ,in the entry point function, you should not directly or indirectly call the LoadLibrary function or the LoadLibraryEx function.
Exporting DLL functions
- To export DLL functions, you can either add a function keyword to the exported DLL functions or create a module definition (.def) file that lists the exported DLL functions.
- To use a function keyword, you must declare each function that you want to export with the following keyword:
  - __declspec(dllexport)
- To use exported DLL functions in the application, you must declare each function that you want to import with the following keyword:
  - __declspec(dllimport)
- Typically, you would use one header file that has a define statement and an ifdef statement to separate the export statement and the import statement.
- You can also use a moudle definition file to declare exported DLL functions. When you use a module definition file, you do not have to add the function keyword to the exproted DLL functions.In the moudle definition file, you declare the LIBRARY statement and the EXPORTS statement for the DLL.
- ```
LIBRARY "DLL"
  EXPORTS
      HelloWorld
```

Sample DLL and application

In Visual Studio 2010, you can create DLL by selecting the Win32 Console Application project type.
The following code is an example of a DLL that was created in VS by using the Win32 Console Application
dllmain.cpp:

// dllmain.cpp : Defines the entry point for the DLL application.
  #include "stdafx.h"
  #include "DLL.h"
  #define EXPORTING_DLL

  BOOL APIENTRY DllMain( HANDLE hModule, 
      DWORD  ul_reason_for_call, 
      LPVOID lpReserved
      )
  {
      return TRUE;
  }

  void HelloWorld()
  {
      MessageBox( NULL, TEXT("Hello World"), TEXT("In a DLL"), MB_OK);
  }

DLL.h:

#ifndef INDLL_H
  #define INDLL_H

  #ifdef EXPORTING_DLL
  extern __declspec(dllexport) void HelloWorld() ;
  #else
  extern __declspec(dllimport) void HelloWorld() ;
  #endif

  #endif

The following code is an example of a Win32 Console Application project that calls the exported DLL function in the DLLTest.
DLLTest.cpp:

// DLLTest.cpp : Defines the entry point for the console application.
  //

  #include "stdafx.h"


  int _tmain(int argc, _TCHAR* argv[])
  {
      HelloWorld();
      return 0;
  }

stdafx.h:

// stdafx.h : include file for standard system include files,
  // or project specific include files that are used frequently, but
  // are changed infrequently
  //

  #pragma once

  #include "targetver.h"
  #include "DLL.h"
  #include <stdio.h>
  #include <tchar.h>
  #pragma comment(lib,"DLL.lib")


  // TODO: reference additional headers your program requires here

Note In load-time dynamic linking, you must link the DLL.lib import library that is created when you build the DLLTest project.
In run-time dynamic linking, you use code that is similar to the following code to call the DLL.dll exported DLL function.

// DLLTest.cpp : Defines the entry point for the console application.
  //

  #include "stdafx.h"
  #include <Windows.h>
  typedef VOID (*DLLPROC) ();

  int _tmain(int argc, _TCHAR* argv[])
  {
      HINSTANCE hinstDLL;
      DLLPROC HelloWorld;
      BOOL fFreeDLL;

      hinstDLL = LoadLibrary("DLL.dll");
      if (hinstDLL != NULL)
      {
          HelloWorld = (DLLPROC) GetProcAddress(hinstDLL, "HelloWorld");
          if (HelloWorld!=NULL)
          {
              HelloWorld();
          }


          fFreeDLL = FreeLibrary(hinstDLL);
      }
      getchar();
      ///HelloWorld();
      return 0;
  }

When you compile and link the DLLTest application, the Windows operating system searches for the DLLTest in the following locations in this order:
1. The application folder
2. The current folder
3. The Windows system folder
4. The Windows folder