Dynamic Link Library

aus Wikipedia, der freien Enzyklopädie
(Weitergeleitet von Dynamic link library)
Wechseln zu: Navigation, Suche

Vorlage:Infobox Dateiformat/Wartung/MagischeZahl fehltVorlage:Infobox Dateiformat/Wartung/Standard fehltVorlage:Infobox Dateiformat/Wartung/Website fehlt

Dynamic Link Library
Dateiendung: .dll, .DLL
MIME-Type: application/x-msdownload,
application/octet-stream
Entwickelt von: Microsoft
Art: dynamische Bibliothek

Dynamic Link Library (DLL) bezeichnet allgemein eine dynamische Programmbibliothek, meist bezieht sich der Begriff jedoch auf die von Microsoft für die Betriebssysteme Microsoft Windows und OS/2 verwendete Variante.

DLL-Dateien verwenden das auch für ausführbare EXE-Dateien gebräuchliche Dateiformat, das in 16-Bit-Programmen das New-Executable-Format (NE)[1] und in 32- und 64-Bit-Programmen das Portable-Executable-Format (PE) hat. Sowohl EXE- als auch DLL-Dateien können Programmcode (Maschinencode), Daten und Ressourcen in irgendeiner Kombination enthalten.

Die Windows-Dateinamenserweiterung für solche Bibliotheken ist gewöhnlich DLL, es können auch andere Dateiendungen wie OCX (für Bibliotheken mit ActiveX-Steuerelementen) sein.

Hintergrund[Bearbeiten]

Hauptartikel: Programmbibliothek

Der Zweck von DLL-Dateien ist, 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, wird deshalb in einer einzelnen Datei auf der Festplatte gespeichert und nur einmal in den Hauptspeicher geladen, wenn mehrere Programme dieselbe Programmbibliothek benötigen.

Weitere Vorteile[Bearbeiten]

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 in diesem Fall auf die aktualisierte Fassung zugreifen. Dadurch ist es Softwareentwicklern möglich, relativ kleine Patches für größere Softwarepakete herauszugeben, beispielsweise auch für ganze Betriebssysteme. Ein ganzes Paket kann so durch die Aktualisierung 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 zum Beispiel unter Windows durch ActiveX realisiert.

Auch können durch solch einen modularen Aufbau einfach nicht benötigte Funktionen deaktiviert werden.

Schwächen[Bearbeiten]

Ein bei Windows auch DLL-Konflikt genanntes Problem tritt auf, wenn mehrere Anwendungen verschiedene Versionen der gleichen DLL benötigen. Falls einem Programm die erforderliche Version fehlt, kann das zu Problemen, wie fehlerhaften Installationen, führen. Dieser Konflikt kann oft behoben werden, indem die jeweils richtige Version der Programmbibliothek in den Programmordner des jeweiligen Programms kopiert wird. Der Effekt der Speicherersparnis wird dadurch allerdings wieder zunichtegemacht. Mit Microsoft .NET ist es möglich, Versionskonflikte bei DLL-Dateien zu umgehen, indem sie die gleichzeitige Existenz von mehreren Versionen einer Programmbibliothek ermöglichen. Dies ist aber nur für mit .NET entwickelte DLL-Dateien möglich.

In bestimmten Fällen ist DLL Hijacking oder die bösartige Nutzung von DLL-Injection möglich.

Betriebssysteminterne Behandlung[Bearbeiten]

Laden von DLLs bei einem Programmstart[Bearbeiten]

Wenn ein Programm ausgeführt werden soll, dann wird es vom Loader des Betriebssystems in den Speicher geladen und die Import-Table des Programms 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 Programms die Einsprungadressen der einzelnen Befehle ein.

DLL-Datei-Aufbau[Bearbeiten]

Eine DLL hat denselben NE-Header oder PE-Header wie eine normale ausführbare Datei, nur ist im Falle einer NE der DWORD-Flag an der Adresse 0Ch im NE-Header auf 8000h gesetzt (Library Module flag)[1] beziehungsweise im PE-Header im Characteristics-Wert das IMAGE_FILE_DLL-Bit gesetzt. Während sowohl DLLs als auch ausführbare Dateien eine Export-Table besitzen können, wird dies bei letzteren selten benutzt. In dieser „Export-Table“ sind alle Namen der Funktionen und Variablen aufgelistet, die die DLL an externe Software zur Verfügung stellt. Diese Namen müssen alphabetisch sortiert sein, damit der Loader sie finden kann.

Aufruf eines DLL-Befehles durch ein Programm[Bearbeiten]

Zuerst werden die zu übergebenden 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[Bearbeiten]

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[Bearbeiten]

Jedes Mal, 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 muss.

Programmierbeispiele für 32-Bit Windows[Bearbeiten]

Arbeiten mit DLLs in Visual C++[Bearbeiten]

Erstellen einer DLL mit einer Funktion[Bearbeiten]

Die DLL-Schnittstelle wird mit Hilfe der Export-Funktion __declspec(dllexport) definiert.
Dies wird im folgenden Beispiel demonstriert:

// Nur unter Microsoft Visual C++ hat das Makro "DLL" eine Funktion.
// Unter z.B. Linux ist das Makro "DLL" leer.
 
#if defined(_MSC_VER)
 #include <windows.h>
 #define DLL   extern "C" __declspec(dllexport)
#else
 #define DLL
#endif
 
// 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.

Einbinden einer DLL und Aufrufen dieser Funktion[Bearbeiten]

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) ;
 
int main (void)
{
    // Aufrufen der externen Funktion
    double result = AddNumbers (1, 2) ;
 
    printf ("Das Ergebnis ist: %f\n", result) ;
    return 0 ;
}

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, damit er „Platzhalter“ für die später aus der DLL aufgerufenen Funktionen einbauen kann.

Einbinden einer DLL zur Laufzeit und Aufrufen dieser Funktion[Bearbeiten]

DLL-Bibliotheken können auf zwei verschiedene Weisen in eine Anwendung geladen werden, entweder mit dem Starten des Programms (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 anhand eines VC++-Beispieles:

#include <windows.h>
#include <stdio.h>
 
// Definition des Types der DLL-Funktion, die verwendet werden soll
typedef double (*BinaryFunction_t) (double, double) ;
 
int main (void)
{
    BinaryFunction_t  AddNumbers  ;
    double            result      ;
    BOOL              fFreeResult ;
 
    // DLL Datei laden
    HINSTANCE         hinstLib = LoadLibrary ("MyDll.dll") ;
 
    if (hinstLib != NULL)
    {
        // Die Einsprungadresse abfragen
        AddNumbers = (BinaryFunction_t) GetProcAddress (hinstLib, "AddNumbers") ;
 
        // Die Funktion aufrufen
        if ( AddNumbers != NULL )
            result = (*AddNumbers) (1, 2) ;
 
        // Die DLL-Datei wieder entladen
        fFreeResult = FreeLibrary (hinstLib) ;
    }
 
    // Das Ergebnis anzeigen
    if (hinstLib == NULL  ||  AddNumbers == NULL)
        printf ("Fehler: Konnte die Funktion nicht aufrufen\n") ;
    else
        printf ("Das Ergebnis ist: %f\n", result) ;
 
    return 0 ;
}

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 mitladen 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.

Verwenden von DLLs in Object Pascal[Bearbeiten]

Erstellen einer DLL[Bearbeiten]

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
  Result := a + b;
end;
// Exportieren der Funktion
exports
  AddNumbers;
// In diesem Fall muss kein spezieller Initialisierungs-Quellcode angegeben werden
begin
end.

Eine DLL einbinden / aufrufen[Bearbeiten]

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 'Beispiel.dll';

var result: Double;
begin
  result := AddNumbers(1, 2);
  Writeln('Das Ergebnis ist: ', result)
end.

DLLs in Visual Basic Classic verwenden[Bearbeiten]

Von VB bis zur Version 6 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 On
 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. Weiterhin muss man die Aufrufkonvention der exportierten Funktion beachten: Visual Basic nimmt an, dass die Funktion _stdcall ist. Deshalb war bis VB7 der Import von _cdecl-Funktionen nur über eine zwischengeschaltete Wrapper-DLL möglich.

Win32-DLLs im .NET verwenden[Bearbeiten]

In .NET werden DLLs mithilfe des DllImport-Attributs eingebunden. Dazu ist der Namespace „System.Runtime.InteropServices“ nötig. Der Funktionsprototyp wird in C# als „extern“ angegeben, was in VB.NET nicht nötig ist, anschließend kann die Funktion wie jede andere angesprochen werden:

C#[Bearbeiten]

using System;
using System.Runtime.InteropServices;
 
namespace DllImportBeispiel
{
    class Program
    {
        [DllImport("Example.dll")]
        static extern double AddNumbers(double a, double b);
 
        static void Main()
        {
            Console.WriteLine( AddNumbers( 1, 2 ) );
        }
    }
}

VB.NET[Bearbeiten]

Imports System.Runtime.InteropServices
 
Class Program
  <DllImport("Example.dll")> _
  Private Shared Function AddNumbers(a As Double, b As Double) As Double
  End Function
 
  Private Shared Sub Main()
    Console.WriteLine(AddNumbers(1, 2))
  End Sub
End Class

Siehe auch[Bearbeiten]

  • Dependency Walker, Bestandteil des Microsoft Visual Studio bis zur Version 2005, mit dem man sich Funktionen, die ein Programm ex- und importiert, hierarchisch anzeigen lassen kann.

Einzelnachweise[Bearbeiten]

  1. a b Microsoft KB: Executable-File Header Format

Weblinks[Bearbeiten]