Eine Dynamic-Link Library (DLL) ist eine unter Microsoft Windows verwendete Programmbibliothek. Solche Bibliotheken haben gewöhnlich die Dateiendung DLL, OCX (für Bibliotheken mit ActiveX Steuerelementen) oder ICL (für Bibliotheken, die nur Gerätebilder, so genannte Icons, enthalten).
Das Dateiformat für DLLs ist dasselbe wie bei Windows-Programmen (EXEs). Sowohl EXEs als auch DLLs können Programmcode (Maschinencode), Daten, und Ressourcen, in irgendeiner Kombination enthalten. Zum Beispiel enthalten ICL-Dateien keinen Programmcode.
Hintergrund
DLLs wurden eingeführt, um den von einer Anwendung auf der Festplatte und im Hauptspeicher benötigten Speicherplatz zu reduzieren. Jeglicher Programmcode, der von mehr als einer Anwendung benötigt werden könnte, wurde deshalb in einer einzelnen Datei auf der Festplatte gespeichert und nur einmal in den Hauptspeicher geladen, wenn mehrere Programme die gleiche DLL benötigten. Durch weitgehende Auslagerung möglichst vieler Funktionen war es einigen der ersten Windows-Versionen möglich, mit extrem wenig Arbeitsspeicher auszukommen.
Vorteile
Ein weiterer Vorteil von DLLs ist ihre Modularität:
Wird ein Stück Programmcode verbessert, müssen nicht alle Programme geändert werden, die diesen Code nutzen, sondern es genügt, ihn in der DLL zu aktualisieren. Alle Programme können nun auf die aktualisierte Fassung zugreifen. Dadurch ist es Software-Herstellern möglich, relativ kleine Service Packs für große Softwarepakete herauszugeben, wie zum Beispiel für Microsoft Office, Microsoft Visual Studio oder auch für Windows selbst. Das ganze Paket kann so durch den Austausch einzelner DLLs auf den neuesten Stand gebracht werden.
In Form von Plug-Ins können mit DLLs neue Programmteile für ein bereits bestehendes Programm erstellt und darin nahtlos integriert werden, ohne dass am schon existierenden Programm Veränderungen vorgenommen werden müssten. Diese Idee der dynamischen „Einbindbarkeit“ wird von ActiveX auf die Spitze getrieben.
Schwächen
Ein auch DLL Hell genanntes Problem tritt auf, wenn mehrere Anwendungen verschiedene Versionen der gleichen DLL benötigen. Dieser Konflikt kann behoben werden, indem die jeweils richtige Version der Programmbibliothek in den Programmordner des jeweiligen Programmes kopiert wird. Der Effekt der Speicherersparnis wird dadurch allerdings wieder zunichte gemacht. Microsoft .NET umgeht Probleme mit Versionskonflikten bei DLLs, indem es die gleichzeitige Existenz von mehreren Versionen einer Programmbibliothek erlaubt. Bei den heutigen Computern, die ausreichend Arbeits- und Festplattenspeicher besitzen, ist das ein sinnvoller Weg, um der „DLL Hell“ vorzubeugen.
Programmierbeispiele
Arbeiten mit DLLs in Visual C++
Erstellen einer DLL
Die DLL-Schnittstelle wird mit Hilfe der Export-Funktion __declspec(dllexport) definiert. Dies wird im folgendem Beispiel demonstriert:
#include <windows.h>
#if defined(_MSC_VER)
#define DLL __declspec(dllexport)
#else
#define DLL
#endif
// nur unter MS VC das Symbol DLL definieren unter zum Beispiel Linux wird DLL ignoriert
// Die Funktion, die anderen Programmen zur Verfügung gestellt werden soll
// (in diesem Beispiel: Addieren zweier Zahlen)
DLL
double AddNumbers (double a, double b) {
return a + b;
}
Dieses Beispiel erzeugt beim Compilieren sowohl eine DLL als auch eine LIB-Datei.
Eine DLL einbinden / aufrufen
DLL Funktionen können einfach aufgerufen werden, nachdem man sie mit der Funktion __declspec(dllimport) importiert hat.
#include <windows.h>
#include <stdio.h>
// Importieren der Funktion aus der oben erstellten DLL
extern "C" __declspec(dllimport)double AddNumbers (double a, double b);
void main () {
// Aufrufen der externen Funktion
double result = AddNumbers(1, 2);
printf("Das Ergebnis ist: %f\n", result);
}
Zu beachten ist, dass der Linker die LIB Datei benötigt und dass sich die DLL-Datei im selben Ordner wie das Programm, das sie aufrufen soll, befinden sollte. Die LIB Datei wird vom Linker benötigt, da diese - ähnlich einer Header Datei - die Funktionsprototypen enthält.
Verwenden von DLLs mit Borland Delphi
Erstellen einer DLL
Im Kopf des Quellcodes muss das Schlüsselwort library an Stelle von program verwendet werden. Am Ende der Datei werden dann die zu exportierenden Funktionen im exports-Bereich aufgelistet,
library Beispiel; // Die Funktion, die anderen Programmen zur Verfügung gestellt werden soll // (in diesem Beispiel: Addieren zweier Zahlen) function AddNumbers(a, b: Double): Double; cdecl; begin AddNumbers := a + b end; // Exportieren der Funktion exports AddNumbers; // In diesem Fall muss kein spezieller Initialisierungs-Quellcode angegeben werden begin end.
Eine DLL einbinden / aufrufen
Delphi benötigt keine LIB-Dateien, um eine Funktion korrekt importieren zu können. Zum Einbinden einer DLL muss lediglich das Schlüsselwort external verwendet werden:
program Beispiel;
{$APPTYPE CONSOLE}
// Importieren der Funktion aus einer externen DLL
function AddNumbers(a, b: Double): Double; cdecl; external 'Example.dll';
var result: Double;
begin
result := AddNumbers(1, 2);
Writeln('Das Ergebnis ist: ', result)
end.
Einbinden von DLLs zur Laufzeit
DLL-Bibliotheken können auf zwei verschiedene Weisen in eine Anwendung geladen werden, entweder mit dem Starten des Programmes (so wie in den obigen Beispielen beschrieben) oder während der Laufzeit, indem man die API-Funktionen LoadLibrary, GetProcAddress und FreeLibrary verwendet. Die Art und Weise, wie DLLs während der Laufzeit einzubinden sind, ist in jeder Programmiersprache gleich, solange man eine Windows API-Funktion importieren möchte. Der folgende Code demonstriert das an Hand eines VC++ Beispieles:
#include <windows.h>
#include <stdio.h>
// Definition der DLL-Funktion, die verwendet werden soll
typedef double (*AddNumbers)(double, double);
int main () {
AddNumbers function;
double result;
// DLL Datei laden
HINSTANCE hinstLib = LoadLibrary("MyDll.dll");
if (hinstLib) {
// Die Einsprungadresse abfragen
function = (AddNumbers) GetProcAddress(hinstLib, "AddNumbers");
// Die Funktion aufrufen
if (function)
result = (function) (1,2);
// Die DLL-Datei wieder entladen
BOOL fFreeResult = FreeLibrary(hinstLib);
}
// Das Ergebnis anzeigen
if (!hinstLib || !function)
printf("Fehler: Konnte die Funktion nicht aufrufen\n");
else
printf("Das Ergebnis ist: %f\n", result);
}
Die LIB-Datei wird in diesem Fall nicht benötigt. Die DLL-Datei muss aber immer noch in einem Ordner liegen, der dem Programm zugänglich ist.
Zu beachten ist außerdem, dass beim Versuch, eine nicht vorhandene DLL direkt beim Programmstart automatisch mit laden zu lassen, vom Betriebssystem eine Fehlermeldung angezeigt und das Programm beendet wird, ohne dass der Programmierer eine Möglichkeit hat, diesen Fehler abzufangen. Beim Einbinden von DLLs während der Laufzeit können Fehler beim Laden hingegen abgefangen werden.
DLLs in Visual Basic verwenden
Von VB wird nur das Laden von DLLs während der Laufzeit unterstützt. Zusätzlich zur Verwendung der API-Funktionen LoadLibrary und GetProcAddress ist es in Visual Basic aber möglich, externe DLL-Funktionen zu deklarieren, was für den Entwickler diese Arbeit um einiges einfacher macht:
Option Explicit
Declare Function AddNumbers Lib "Example.dll" (ByVal a As Double, ByVal b As Double) As Double
Sub Main()
Dim Result As Double
Result = AddNumbers(1, 2)
Debug.Print "Das Ergebnis ist: " & Result
End Sub
Wenn beim Laden der DLL-Funktion ein Fehler auftritt, löst VB einen Laufzeitfehler aus. Dieser kann aber abgefangen und behandelt werden.
Internes Handling
Laden von DLLs bei einem Programmstart
Wenn ein Programm ausgeführt werden soll, dann wird es vom Loader des Betriebssystem in den Speicher geladen und die Import-Table des Programmes ausgelesen. In dieser Tabelle befinden sich alle DLL-Befehls-Namen oder die Ordnungszahlen der DLL-Befehle, die von diesem Programm benötigt werden. Der Loader lädt nun die fehlenden DLLs in den Speicher und fügt in der Import-Table des Programmes die Einsprungadressen der einzelnen Befehle ein.
DLL-Datei Aufbau
Eine DLL hat den selben PE-Header wie eine normale ausführbare Datei, nur ist im Characteristics-Wert das IMAGE_FILE_DLL-Bit gesetzt. Die DLL hat zusätzlich eine Export-Table, in der alle Namen der Befehle aufgelistet sind, die die DLL zur Verfügung stellt. Diese Namen müssen alphabetisch sortiert sein, damit der Loader sie finden kann.
Aufruf eines DLL-Befehles durch ein Programm
Zuerst werden die zu übergebenen Werte auf dem Stack abgelegt, dann wird ein indirekter Sprung auf den Wert der vom Loader in der Import-Tabelle hinterlegten DLL-Adresse durchgeführt.
DLLs im Speicher
Es gibt zwei verschiedene Arten, wie DLLs vom Betriebssystem in den Speicher geladen werden. Es gibt statische DLLs, die nur einmal geladen werden. Alle Programme greifen dann auf diese eine Instanz der DLL zu. Diese DLL hat dann nur einen globalen Speicherbereich. Die Windows-Kernel-DLLs sind solche statischen DLLs, was ihnen erlaubt, das gesamte System zu verwalten (z. B. alle offenen Dateien zu überwachen). Die andere Art, wie eine DLL im Speicher verwaltet werden kann, ist die, dass jedes mal wenn ein neues Programm sie benötigt, auch eine neue Instanz von ihr in den Speicher geladen wird. Ob eine DLL statisch oder nicht ist legt ein weiteres Flag im Header der DLL fest.
DLL-Instanzenzähler
Jedesmal, wenn eine DLL von einem Programm geladen wird, wird ein interner Instanzenzähler für diese DLL erhöht. Über diesen Zähler kann das System erkennen, ob eine DLL noch in Verwendung ist oder entladen werden kann. Letzteres geschieht, wenn der Instanzenzähler Null erreicht, da das letzte laufende Programm, welches die DLL benutzt hat, die DLL entladen hat und diese nicht weiter im Speicher vorgehalten werden braucht.
Siehe auch
- Dependency walker, ein hübsches Werkzeug von Microsoft, mit dem man sich alle Funktionen, die ein Programm exportiert und importiert, anzeigen lassen kann.
Links
- dllexport, dllimport auf MSDN
- Win32 DLL auf www.functionx.com. Tutorial, wie man DLLs erstellt und aufrufen kann.