Créer une DLL Windows avec Visual basic

Date de publication : 26/04/2005 , Date de mise à jour : 29/06/2009

Par Ron Petrusha (Version originale)
 Traduction : bbil, (page à bbil)
 sur une idée de medkarim
 

Même si cela est peu documenté, il est possible de créer en VB6 une DLL standard Windows.
Je vous propose de retrouver ici une traduction d'un article de Ron Petrusha dont vous pouvez trouver
l'original en anglais ici : « Creating a Windows DLL with Visual Basic »
4 commentaires

               Version PDF (Miroir)   Version hors-ligne (Miroir)



1. Introduction

En tant que premier programme de développement rapide d'application, Visual Basic a attiré l'attention pour son élégante interface graphique et sa facilité globale d'utilisation.

Ce qui a permis avec relativement peu d'expérience de programmation de réaliser en quelques minutes ce qui aurai pris des jours pour les programmeurs utilisant des langages comme C et C ++.

Grâce à cela Visual Basic a attiré des millions de nouveaux programmeurs, dont beaucoup n'auraient jamais envisagé de ce risquer à la programmation s'il n'y avait pas eu la simplicité de ce langage.

En raison de cette simplicité, et parce que Visual Basic a attiré un public que les partisans d'autres langages ne peuvent que rêver, les non utilisateurs de Visual Basic (qui étaient vraiment vert de jalousie) contre-attaquèrent en pointant l'inexpérience de la plupart des programmeurs Visual Basic et des problèmes qui découlent de la protection du développeur vis à vis de la complexité du système d'exploitation par l'IDE Visual Basic .

Pour soutenir leur thèse désignant Visual Basic comme un sous-produit, sous-développé, les critiques mettent l'accent sur les choses que les « vrai » programmeurs font et qui sont inaccessibles aux programmeurs Visual Basic.

Peut-être la plus courante de ces restrictions, que les critiques mettent sans cesse en avant et l'incapacité de Visual Basic à créer un standard de Windows : une bibliothèque de liens dynamiques (DLL) .

Certes, il est vrai qu'au déballage de la boîte, Visual Basic ne vous permet pas de créer une DLL Windows de la même manière que vous pouvez créer d'autres types de projets, comme un Standard EXE ou une DLL ActiveX. Dans cet article, nous allons explorer Visual Basic afin de voir comment il génère des exécutables. Dans le processus, nous allons découvrir qu'avec un peu de travail supplémentaire, nous pouvons en effet créer des DLL de Windows avec Visual Basic.


2. Qu'est-ce qu'une bibliothèque Windows de liens dynamique

Une bibliothèque de lien dynamique (DLL) est une bibliothèque de fonctions et de procédures qui peuvent être appelées d'une application ou d'un autre DLL. L'utilisation d'une bibliothèque a de cette manière deux fonctions importantes :

  • Elle permet le partage de code. La même DLL pouvant être utilisée par de nombreuses autres applications et autres DLL. L'API Win32, par exemple, est mis en œuvre comme une série de DLL de Windows. De plus, aussi longtemps que des processus multiples chargent la même DLL à la même adresse de base, ils peuvent partager le code de la DLL. En d'autres termes, une seule DLL dans la mémoire peut être utilisée par de multiples processus.
  • Elle permet d'effectuer un développement à base de composants modulaires, qui rend plus facile le développement et le processus de mise à niveau.
Habituellement, quand une bibliothèque statique est utilisée dans le développement d'applications, les modules de la bibliothèque doivent être incorporés dans l'application finale. Avec la liaison dynamique, les modules résident dans un fichier DLL qui est chargé dynamiquement, soit au chargement de l'application ou lorsque devient nécessaire l'appel d'une de ses fonctions membres.

Une bibliothèque de lien dynamique peut inclure les fonctions internes, accessibles seulement dans la DLL. Son but principal, est cependant, de fournir des fonctions exportées, c'est-à-dire, fonctions qui résident dans un module de la DLL et peuvent s'appeler d'autres DLLs et applications. Fréquemment, un fichier de définition (.def) est utilisé dans les projets C/C++ pour énumérer les exportations d'un DLL.

Une DLL inclut également un point d'entrée facultatif, qui est appellé quand un processus ou un thread charge ou décharge une DLL. Windows ce charge d'effectuer cet appel au chargement ou déchargement d'un processus et aussi quand le processus crée ou termine un thread. Cela permet à la DLL d'effectuer pour chacun des processus et applications l'initialisation et le nettoyage. La syntaxe de ce point d'entrée, qui respecte les conventions standard d'appel (employée par défaut dans Visual Basic), est : 
Public Function DllMain(hinstDLL As Long, fdwReason As Long, 
   lpwReserved As Long) As Boolean
Ces paramètres sont :

hInstDLL, un long contenant le handle de l'instance de la DLL. Qui est identique au handle du module de la DLL.

fdwReason, une constante indiquant pourquoi le point d'entrée s'est appelé. Les valeurs possibles sont :

  • DLL_PROCESS_ATTACH (1)
    Un processus charge la DLL. N'importe quelle initialisation « par processus » devrait être exécutée.
  • DLL_THREAD_ATTACH (2)
    Le processus engendre un nouveau thread. Tout « par thread » initialisation devrait être exécuté.
  • DLL_THREAD_DETACH (3)
    Un thread se termine. Tout « par-thread » de nettoyage devrait être exécuté.
  • DLL_PROCESS_DETACH (0)
    Un processus détache le DLL, ou le processus se termine. N'importe quel nettoyage de « par-processus » devrait être exécuté.
  • LpvReserved Un long qui fournit plus d'informations au sujet de DLL_PROCESS_ATTACH et de DLL_PROCESS_DETACH. (Il est inutilisé si le fdwReason est DLL_THREAD_ATTACH ou DLL_THREAD_DETACH.)
    • Si fdwReason est égal à DLL_PROCESS_ATTACH : retourne nothing pour les bibliothèques chargées dynamiquement utilisant des fonctions comme LoadLibrary et GetProcAddress, et retourne nothing pour les bibliothèques chargées statiquement en fournissant des « stubs » de bibliothèque au moment de la compilation.
    • Si fdwReason est DLL_PROCESS_DETACH : retourne nothing si l'appel a résulté d'un appel à la fonction de Win32 FreeLibrary, ou si le point d'entré est appelé pendant l'arrêt de processus.
La valeur de retour de la fonction n'est significative que dans le cas ou fdwReason est égal à DLL_PROCESS_ATTACH.

Si l'initialisation réussit, la fonction devrait renvoyer vrai ; autrement, elle devrait renvoyer faux. Notez que comme la fonction est un point d'entrée appelé par Windows, les valeurs des arguments passés à la celle-ci sont fournies par Windows. En outre, le point d'entrée n'est pas exécuté lorsque un thread est terminé en utilisant la fonction de Win32 TerminateThread, de même il n'est pas exécuté quand un processus est terminé en utilisant la fonction de Win32 TerminateProcess.


3. Le Code exemple d'une DLL

Dans notre progression pour développer une DLL pour Windows, nous créerons une bibliothèque très simple des fonctions mathématiques. Ce qui suit est le code de la DLL, que nous allons enregistrer dans un module de code (un ficher .bas) nommé MathLib :
Fichier MathLib.bas
Option Explicit

Public Const DLL_PROCESS_DETACH = 0
Public Const DLL_PROCESS_ATTACH = 1
Public Const DLL_THREAD_ATTACH = 2
Public Const DLL_THREAD_DETACH = 3

Public Function DllMain(hInst As Long, fdwReason As Long, _
  lpvReserved As Long) As Boolean
   Select Case fdwReason
      Case DLL_PROCESS_DETACH
         ' No per-process cleanup needed
      Case DLL_PROCESS_ATTACH
         DllMain = True
      Case DLL_THREAD_ATTACH
         ' No per-thread initialization needed
      Case DLL_THREAD_DETACH
         ' No per-thread cleanup needed
   End Select
End Function

Public Function Increment(var As Integer) As Integer
   If Not IsNumeric(var) Then Err.Raise 5
   
   Increment = var + 1
End Function

Public Function Decrement(var As Integer) As Integer
   If Not IsNumeric(var) Then Err.Raise 5
   
   Decrement = var - 1
End Function

Public Function Square(var As Long) As Long
   If Not IsNumeric(var) Then Err.Raise 5
   
   Square = var ^ 2
End Function
Plusieurs caractéristiques du code doivent être signalé.

La première est que bien qu'il inclut une procédure DllMain, aucun processus «par thread » ou d'initialisation ne doit être exécuté. Ainsi DllMain renvoie simplement vrai si elle est appelée avec l'argument fdwReason égal à DLL_PROCESS_ATTACH.

En second lieu, le but de fournir un DLL de Windows est de permettre à d'autres langages de l'appeler. Pour assurer l'interopérabilité, nous voulons nous limiter aux caractéristiques de langages qu'utilise l'API Win32, de sorte que notre DLL puisse être appelé par le plus grand nombre d'environnements et plates-formes de développement possible. Nous aurions pu rendre chacune de nos trois fonctions mathématiques plus flexibles, par exemple, en définissant l'argument entrant et la valeur de retour comme Variant. Cela aurait permis à la fonction de déterminer le type de données qu'elle devrait utiliser pour interpréter les données entrantes et aussi le type de données qu'elle devrait retourner. Mais le variant est un type de données défini par COM, « Microsoft Composant Object Model », et n'est pas un type de données reconnu par Win32 api . Ainsi à la place, le code emploie les types de données standard de Win32 api.

Nous aurons besoin également d'un programme de test pour vérifier si notre DLL de Windows fonctionne correctement. Dans ce but, nous pouvons créer un projet standard d'EXE avec une forme et un module de code. Le module comprenant simplement les déclarations qui définissent les fonctions se trouvant dans la DLL :
Déclaration des fonctions de la DLL
Public Declare Function Increment Lib "MathLib.dll" (var As Integer) As Integer

Public Declare Function Decrement Lib "MathLib.dll" (var As Integer) As Integer

Public Declare Function Square Lib "MathLib.dll" (var As Long) As Long
Plutôt que simplement spécifier le nom de la DLL dans la clause lib, vous devez ajouter le chemin complet vers le répertoire qui contient la DLL.

Le code de la form exécutant les appels aux fonctions de DLL :
Code de la form test des appels
Option Explicit
Dim incr As Integer
Dim decr As Integer
Dim sqr As Long
Private Sub cmdDecrement_Click()
   decr = Decrement(decr)
   cmdDecrement.Caption = "x = " & CStr(decr)
End Sub
Private Sub cmdIncrement_Click()
   incr = Increment(incr)
   cmdIncrement.Caption = "x = " & CStr(incr)
End Sub

Private Sub cmdSquare_Click()
   sqr = Square(sqr)
   cmdSquare.Caption = "x = " & CStr(sqr)
End Sub

Private Sub Form_Load()
   incr = 1
   decr = 100
   sqr = 2
End Sub

4. Le type de projet DLL ActiveX

Commençons par créer un projet DLL ActiveX et voyons ce qui se produit si nous essayons de l'appeler comme si c'étaient une DLL standard de Windows.

Quand vous créez un projet DLL ActiveX, Visual Basic ajoute automatiquement un module de classe (un fichier .cls) à lui. Vous pouvez le renommer si vous voulez, mais ni incluez aucun code. Au lieu de cela, ajoutez un module de code (un fichier .bas) au projet, ajoutez y le code de la DLL vu précédemment, et compilez le projet. Quand vous lancez l'application de test de la DLL, et actionnez le bouton incrément, la boîte de dialogue de message d'erreur représenté en figure 1 apparaît. Le message d'erreur indique que bien que la DLL a été trouvé, mais qu'elle ne comporte pas la fonction spécifique (incrément) .

Figure 1. Erreur lors de l'accès à une ActiveX DLL à la manière d'une Windows DLL
La cause le plus probable de cette erreur est que la fonction n'est actuellement pas exportée par la DLL. Nous pouvons employer l'utilitaire DumpBin pour examiner les exportations d'une DLL en employant la syntaxe :
Dumpbin <path and name of dll> /exports
Si nous exécutons DumpBin en utilisant cette syntaxe, nous avons le retour suivant :
Microsoft (R) COFF Binary File Dumper Version 6.00.8447
Copyright (C) Microsoft Corp 1992-1998. All rights reserved.


Dump of file mathlib.dll

File Type: DLL

  Section contains the following exports for MathLib.dll

           0 characteristics
    41B9E52C time date stamp Fri Dec 10 10:04:28 2004
        0.00 version
           1 ordinal base
           4 number of functions
           4 number of names

    ordinal hint RVA      name

          1    0 0000192E DllCanUnloadNow
          2    1 00001902 DllGetClassObject
          3    2 00001918 DllRegisterServer
          4    3 000018EC DllUnregisterServer

  Summary

        1000 .data
        1000 .reloc
        1000 .rsrc
        1000 .text
Notre DLL exporte quatre fonctions, qui sont des fonctions de service qui supportent COM. Cependant nous devons exporter DllMain et nos trois fonctions mathématiques. Mais comment ? Visual Basic ne semble pas permettre d'exporter des fonctions de DLL ActiveX, de ce fait vous empêche d'employer Visual Basic pour créer une DLL standard de Windows.

Cette difficulté, n'est cependant pas insurmontable. Lorsque nous choisissons la commande fichier -> créer <fichier>.dll pour créer la DLL d'ActiveX, il semble que Visual Basic prenne notre code source et produise la DLL ActiveX.

Mais si nous examinons le sous-répertoire dans lequel Visual Basic a été installé, il s'avère que le processus n'est pas tout à fait exécuté de maniére transparente . Avec VB6.EXE, l'exécutable de Visual Basic qui en définit l'environnement, nous pouvons également trouver C2.EXE et LINK.EXE, qui sont respectivement un compilateur et un éditeur de liens. Leur présence dans ce répertoire suggère que VB6.EXE lui-même ne s'occupe pas de la génération du fichier DLL, mais qu'à un certain point dans le processus de compilation, il appelle ces programmes.

Nous pouvons découvrir comment Visual Basic emploie le compilateur et l'éditeur de liens avec plus précision en les renommant et en créant des exécutables d'emballage appelés C2 et LINK qui appellent à leur tour les vrais compilateur et éditeur de liens. Ce qui suit est le code source pour une nouvelle version en mode console de C2.EXE qui appelle le « vrai » compilateur C2, que nous avons renommé C2Comp.exe :
Le « faux » C2.exe
Public Sub Main()
On Error Resume Next
   Dim strCmd As String, strPath As String
   Dim oFS As New Scripting.FileSystemObject
   Dim ts As TextStream
   strCmd = Command
   strPath = App.Path
   Set ts = oFS.CreateTextFile(strPath & "\c2log.txt")
   ts.WriteLine "Beginning execution at " & Date & " " & Time()
   ts.WriteBlankLines 1
   ts.WriteLine "Command line parameters to c2 call:"
   ts.WriteLine "   " & strCmd
   ts.WriteBlankLines 1
   ts.WriteLine "Calling C2 compiler"
   Shell "c2comp.exe " & strCmd
   If Err.Number <> 0 Then
      ts.WriteLine "Error in calling C2 compiler..."
   End If
   ts.WriteBlankLines 1
   ts.WriteLine "Returned from c2 compiler call"
   ts.Close
End Sub
Le processus de compilation d'une DLL ActiveX produit la sortie suivante dans notre fichier de consignation :
Le retour de C2log.txt
Beginning execution at 20/06/2009 21:25:35

Command line parameters to c2 call:
   -il "C:\DOCUME~1\bbil\LOCALS~1\Temp\VB636677" -f "D:\Article_Dvp\documents\create_dll\sources\MathLib\MathLib.bas"
 -W 3 -Gy -G5 -Gs4096 -dos -Zl -Fo
"D:\Article_Dvp\documents\create_dll\sources\MathLib\MathLib.OBJ" -QIfdiv -ML -basic

Calling C2 compiler

Returned from c2 compiler call
Ceux-ci sont des arguments de ligne de commande assez standard, Arguments pour produire les fichiers objets qui, à leur tour, sont fournis à l'éditeur de liens. Cela signifie que pour déterminer comment produire une DLL de Windows, nous devrons intercepter l'appel à l'éditeur de liens de sorte que nous puissions voir quels sont les arguments que lui passe Visual Basic. Le code suivant le fait :
Le « faux » Link.exe d'interception
Public Sub Main()

On Error Resume Next

   Dim strCmd As String, strPath As String
   Dim oFS As New Scripting.FileSystemObject
   Dim ts As TextStream

   strCmd = Command
   
   strPath = App.Path
   
   Set ts = oFS.CreateTextFile(strPath & "\lnklog.txt")
   
   ts.WriteLine "Beginning execution at " & Date & " " & Time()
   ts.WriteBlankLines 1
   ts.WriteLine "Command line parameters to LINK call:"
   ts.WriteLine "   " & strCmd
   ts.WriteBlankLines 1
   ts.WriteLine "Calling LINK linker"
   
   Shell "linklnk.exe " & strCmd
   If Err.Number <> 0 Then
      ts.WriteLine "Error in calling linker..."
      Err.Clear
   End If
   
   ts.WriteBlankLines 1
   ts.WriteLine "Returned from linker call"
   ts.Close
   
End Sub
Il exige que nous renommions l'éditeur de liens LinkLnk.exe et appelons notre emballage Link.exe.

Quand nous essayons de compiler un projet de DLL ActiveX, notre fichier de consignation d'éditeur de liens contient le résultat suivant :
Lnklog.txt
Beginning execution at 20/06/2009 21:40:42

Command line parameters to LINK call:
   "D:\Article_Dvp\documents\create_dll\sources\MathLib\clMAthLb.OBJ"
 "D:\Article_Dvp\documents\create_dll\sources\MathLib\MathLib.OBJ" 
"D:\Article_Dvp\documents\create_dll\sources\MathLib\MathLib1.OBJ"
 "d:\Program Files\Microsoft Visual Studio\VB98\VBAEXE6.LIB" /ENTRY:__vbaS /OUT:"D:\Article_Dvp\documents\create_dll\sources\MathLib\MathLib.dll"
 /BASE:0x11000000 /SUBSYSTEM:WINDOWS,4.0 /VERSION:1.0 /DLL  /INCREMENTAL:NO /OPT:REF /MERGE:.rdata=.text /IGNORE:4078 

Calling LINK linker

Returned from linker call
Si nous comparons les arguments de ligne commande avec la syntaxe requise pour lier les fichiers objets d'une DLL en utilisant soit C ou C++, une omission devient immédiatement évidente. Bien que le commutateur de /DLL soit fourni pour créer une DLL standard, il n'y a aucun commutateur /DEF pour définir un fichier de définition de module (.def) qui énumère les fonctions exportées par la DLL. (Si nous programmions en C ou C++, nous pourrions utiliser des déclarations au sein de notre code pour définir nos exportations. Visual Basic ne permet pas ceci, cependant, créer le fichier .def et le seul moyen de définir les exportations d'une bibliothèque.) D'ailleurs, si nous examinons les dossiers produits pour un projet de DLL ActiveX par l'IDE de Visual Basic, nous constaterons également que Visual Basic lui-même n'a pas produit ce fichier .def.


5. Création de la DLL Windows

Ainsi, après examen de la table de l'exportation d'un DLL d'ActiveX, du résultat de l'interception des appels au compilateur et à l'éditeur de liens par Visual Basic, et après comparaison des arguments passés à l'éditeur de liens à ceux qui sont requis par un compilateur de C/C++ pour générer une DLL Windows, nous avons enfin identifié la raison pour laquelle nous ne sommes pas en mesure de réussir la création une DLL de Windows avec Visual Basic. Et heureusement, on peut contourner cette restriction. Nous devrions être en mesure de créer une DLL standard de Windows, si nous suivons la procédure suivante :

1 - Créez un fichier .def pour notre projet. Nous pouvons préciser nos fonctions exportées dans le fichier .def de plusieurs façons, mais il est préférable de garder les choses simples: 
NAME MathLib
LIBRARY MathMod
DESCRIPTION "Add-on Library of Mathematical Routines"
EXPORTS DllMain @1
        Increment @2
        Decrement @3
        Square @4
La déclaration NAME définit le nom de la DLL. La déclaration LIBRARY doit précéder la liste des fonctions exportées ou apparaitre sur la même ligne que la première fonction. Le fichier .def devrait également énumérer la position ordinale de chaque fonction exportée précédée par un symbole @ .

2 - Décidez de la façon par laquelle voulons intercepter l'appel à l'éditeur de liens. Deux techniques principales sont disponibles pour ce faire :

  • Modifier (Patcher) la table d'adresses d'importation (IAT), ce qui nous oblige à construire un add-in Visual Basic qui modifie l'IAT afin d'intercepter les appels de l'IDE Visual Basic à l'API Win32. Même s'il est certainement la méthode la plus élégante, sa complexité en fait le digne sujet d'un article distinct.
  • Construire un éditeur de lien de substitution qui intercepte l'appel au véritable éditeur de liens, modifier les arguments de la ligne de commande, puis appeler le linker avec ces nouveaux arguments de ligne commande. C'est l'approche que nous avons utilisé pour découvrir quels étaient les arguments passés par Visual Basic au compilateur et à l'éditeur de liens, et c'est cette approche que nous allons adopter pour créer une DLL de Windows.
3  - Modifiez les arguments passés à l'éditeur de liens pour ajouter le commutateur /DEF avec le chemin et le nom de fichier de notre dossier de .def. Pour faire ceci, vous devez créer un projet standard de Visual Basic EXE, ajoutez une référence à la bibliothèque d'exécution Microsoft Scripting Runtime, enlevez la forme du projet, et ajoutez un module de code. Le code source pour l'éditeur de liens par procuration est :
Le « faux linker »
Option Explicit

Public Sub Main()

   Dim SpecialLink As Boolean, fCPL As Boolean, fResource As Boolean
   Dim intPos As Integer
   Dim strCmd As String
   Dim strPath As String
   Dim strFileContents As String
   Dim strDefFile As String, strResFile As String
   Dim oFS As New Scripting.FileSystemObject
   Dim fld As Folder
   Dim fil As File
   Dim ts As TextStream, tsDef As TextStream

   strCmd = Command
   
   Set ts = oFS.CreateTextFile(App.Path & "\lnklog.txt")
   
   ts.WriteLine "Beginning execution at " & Date & " " & Time()
   ts.WriteBlankLines 1
   ts.WriteLine "Command line arguments to LINK call:"
   ts.WriteBlankLines 1
   ts.WriteLine "   " & strCmd
   ts.WriteBlankLines 2
   
   ' Determine if .DEF file exists
   '
   ' Extract path from first .obj argument
   intPos = InStr(1, strCmd, ".OBJ", vbTextCompare)
   strPath = Mid(strCmd, 2, intPos + 2)
   intPos = InStrRev(strPath, "\")
   strPath = Left(strPath, intPos - 1)
   ' Open folder
   Set fld = oFS.GetFolder(strPath)
   
   ' Get files in folder
   For Each fil In fld.Files
      If UCase(oFS.GetExtensionName(fil)) = "DEF" Then
         strDefFile = fil
         SpecialLink = True
      End If
      If UCase(oFS.GetExtensionName(fil)) = "RES" Then
         strResFile = fil
         fResource = True
      End If
      If SpecialLink And fResource Then Exit For
   Next
      
   ' Change command line arguments if flag set
   If SpecialLink Then
      ' Determine contents of .DEF file
      Set tsDef = oFS.OpenTextFile(strDefFile)
      strFileContents = tsDef.ReadAll
      If InStr(1, strFileContents, "CplApplet", vbTextCompare) > 0 Then
         fCPL = True
      End If
      
      ' Add module definition before /DLL switch
      intPos = InStr(1, strCmd, "/DLL", vbTextCompare)
      If intPos > 0 Then
         strCmd = Left(strCmd, intPos - 1) & _
               " /DEF:" & Chr(34) & strDefFile & Chr(34) & " " & _
               Mid(strCmd, intPos)
      End If
      ' Include .RES file if one exists
      If fResource Then
         intPos = InStr(1, strCmd, "/ENTRY", vbTextCompare)
         strCmd = Left(strCmd, intPos - 1) & Chr(34) & strResFile & _
                  Chr(34) & " " & Mid(strCmd, intPos)
      End If
      
      ' If Control Panel applet, change "DLL" extension to "CPL"
      If fCPL Then
         strCmd = Replace(strCmd, ".dll", ".cpl", 1, , vbTextCompare)
      End If
      
      ' Write linker options to output file
      ts.WriteLine "Command line arguments after modification:"
      ts.WriteBlankLines 1
      ts.WriteLine "   " & strCmd
      ts.WriteBlankLines 2
   End If
   
   ts.WriteLine "Calling LINK.EXE linker"
   Shell "linklnk.exe " & strCmd
   If Err.Number <> 0 Then
      ts.WriteLine "Error in calling linker..."
      Err.Clear
   End If
   
   ts.WriteBlankLines 1
   ts.WriteLine "Returned from linker call"
   ts.Close
End Sub
Cet éditeur de liens de substitution modifie seulement la commande-ligne arguments passés à l'éditeur de liens si un fichier .def est présent dans le réper qui contient le projet de Visual Basic, dans les autre cas il transmet simplement les arguments de ligne de commande à l'éditeur de liens sans changement. Si un fichier .def est présent, il ajoute un commutateur de /DEF à la ligne de commande. Il détermine également si des dossiers de ressource doivent être ajoutés à la liste de dossier lié. En conclusion, il examine la table d'exportation pour déterminer si une fonction appelée CplApplet est présente, si c'est le cas, il change l'extension .dll du fichier à générer en .cpl.

4 - Pour installer l'éditeur de liens de substitution, renommez l'éditeur de liens original de Visual Basic en Linklnk.exe, copiez l'éditeur de liens de substitution dans le répertoire de Visual Basic, et nommez le link.exe


6. Essai de la DLL

Une fois notre DLL Windows créée, l'étape finale consiste à la tester pour s'assurer que celle-ci fonctionne. Pour ceci, créez un nouveau projet Standard EXE (appelons-le MathLibTest) et ajoutez un nouveau module de code. Pour s'assurer que le code dans notre projet puisse accéder aux fonctions exportées par la DLL, nous employons les déclarations standard de Visual Basic. Nous déclarons nos trois routines mathématiques exportées dans le module de code comme suit :
Déclaration des fonctions
Option Explicit

Public Declare Function Increment Lib "C:\VBProjects\MathLib\mathlib.dll" ( _
                        value As Integer) As Integer
                       
Public Declare Function Decrement Lib "C:\VBProjects\MathLib\mathlib.dll" ( _
                        value As Integer) As Integer
               
Public Declare Function Square Lib "C:\VBProjects\MathLib\mathlib.dll" ( _
                        value As Long) As Long
Nous pouvons alors employer le code suivant dans le module de form pour appeler les routines dans la DLL :
Code de la form de test
Option Explicit

Private Sub cmdDecrement_Click()
   txtDecrement.Text = Decrement(CInt(txtDecrement.Text))
End Sub

Private Sub cmdIncrement_Click()
   txtIncrement.Text = Increment(CInt(txtIncrement.Text))
End Sub

Private Sub cmdSquare_Click()
   txtSquare.Text = Square(CLng(txtSquare.Text))
End Sub

Private Sub Form_Load()
   txtIncrement.Text = 0
   txtDecrement.Text = 100
   txtSquare.Text = 2
End Sub
Lorsque nous appelons chacune des fonctions de MathLib, la fenêtre de l'application devrait apparaître comme dans la figure 2, ce qui confirme que les appels aux routines de MathLib fonctionnent comme prévu.

Figure 2: Essais des appels à MathLib.dll


               Version PDF (Miroir)   Version hors-ligne (Miroir)

Valid XHTML 1.0 TransitionalValid CSS!

Copyright © 2009 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.

Vos questions techniques : forum d'entraide Visual Basic 6 - Publiez vos articles, tutoriels et cours
et rejoignez-nous dans l'équipe de rédaction du club d'entraide des développeurs francophones
Nous contacter - Hébergement - Participez - Copyright © 2000-2010 www.developpez.com - Legal informations.