Creación de un archivo DLL de Windows con Visual Basic

by Ron Petrusha04/26/2005

Como la primera lengua desarrollo rápido de aplicaciones, Visual Basic llamado la atención por su elegante interfaz gráfica y facilidad de uso, lo que permitió un programador con poca experiencia para llevar a cabo en cuestión de minutos lo que a menudo tomó días para programadores avanzados utilizando lenguajes como C y C + +. Como resultado, Visual Basic atrajo a millones de nuevos programadores, muchos de los cuales tal vez nunca han siquiera considerado la programación de no haber sido por la sencillez del lenguaje. Debido a esta simplicidad, y porque Visual Basic fue atrayendo un público que los proponentes de otras lenguas sólo podían soñar, la no-programadores de Visual Basic (que eran realmente verde de envidia) contraatacó señalando a la inexperiencia de la mayoría de los programadores de Visual Basic y al los problemas que se derivan de la meta de diseño de Visual Basic de blindar el revelador de las complejidades del sistema operativo subyacente. Para reforzar su argumento de que Visual Basic es insuficiente y poco desarrollados, los críticos le gustaba señalar las muchas cosas "reales" que los programadores hacen los programadores de Visual Basic no se puede. Tal vez la limitación más común que los críticos señalan continuamente es la incapacidad de Visual Basic para crear una biblioteca estándar de Windows de enlace dinámico (DLL).

Ciertamente es verdad que fuera de la caja, Visual Basic no permite crear un archivo DLL de Windows de la misma manera que se pueden crear otros tipos de proyectos, como un EXE estándar o un archivo DLL de ActiveX. En este artículo vamos a ir a explorar para ver cómo Visual Basic genera sus archivos ejecutables. En el proceso, vamos a descubrir que con un poco de trabajo extra, podemos, de hecho, crear archivos DLL de Windows con Visual Basic.

¿Qué es una biblioteca de Windows Dynamic Link?.

Una librería de enlace dinámico (DLL) es una biblioteca de funciones y procedimientos que se puede llamar desde una aplicación o archivo DLL otro. Uso de una biblioteca de esta forma tiene dos funciones principales:

* Permite el intercambio de código. El mismo archivo DLL puede ser utilizada por muchos otros archivos DLL y las aplicaciones. La API de Win32, por ejemplo, se implementa como una serie de archivos DLL de Windows. Por otra parte, siempre y cuando varios procesos de carga de la misma DLL en la misma dirección base, pueden compartir el código en el archivo DLL. En otras palabras, una única DLL en la memoria se puede acceder por varios procesos. * Se permite el desarrollo basado en componentes y modular, lo que hace que el desarrollo y el proceso de actualización sea más fácil.

Normalmente, cuando una biblioteca estática se utiliza en el desarrollo de aplicaciones, los módulos de la biblioteca debe estar vinculada a la aplicación final. Con la vinculación dinámica, los módulos pueden residir en un archivo independiente “”DLL” que se carga de forma dinámica, ya sea cuando se carga la aplicación o cuando sus funciones miembro son necesarios.

Una librería de enlace dinámico pueden incluir funciones internas, que sólo se puede llamar desde dentro de la DLL. Su objetivo principal, sin embargo, es proporcionar funciones exportadas - es decir, funciones que residen en un módulo de la DLL y se puede llamar desde otros archivos DLL y las aplicaciones. Con frecuencia, una definición (. Def) del archivo se utiliza en C / C + + a la lista de las exportaciones de un archivo DLL.

Un archivo DLL también incluye un punto de entrada opcional, que se llama cuando se carga un proceso o subproceso o descarga el archivo DLL. Windows llama a este punto de entrada cuando se carga un proceso y descarga el archivo DLL. También llama a la puerta de entrada cuando el proceso crea o termina un hilo. Eso permite que el archivo DLL para realizar cualquiera por proceso y la inicialización de cada aplicación y limpieza. La sintaxis de este punto de entrada, que debe utilizar la convención de llamada estándar (usado por defecto en Visual Basic), es:

Public Function DllMain(hinstDLL As Long, fdwReason As Long, lpwReserved As Long) As Boolean

los Parámetros son:

hInstDLL, es un long que contiene el identificador de instancia de la DLL. Este es el mismo módulo

de la DLL de manejar.

fdwReason, una constante que indica por qué el punto de entrada ha sido llamado. Los valores posibles son:

DLL_PROCESS_ATTACH (1)

Un proceso se está cargando el archivo DLL. Cualquier inicialización por proceso se debe realizar.

DLL_THREAD_ATTACH (2)

El proceso está generando un nuevo hilo. Cualquier inicialización por hilo debe ser realizada.

DLL_THREAD_DETACH (3)

Un hilo es la salida. Cualquier limpieza por hilo debe ser realizada.

DLL_PROCESS_DETACH (0)

Un proceso es extraer el archivo DLL, o el proceso está saliendo. Cualquier limpieza por proceso se debe realizar.

lpvReserved

Es un long que proporciona más información acerca de DLL_PROCESS_ATTACH y

DLL_PROCESS_DETACH(que proporciona más información acerca de fdwReason es

DLL_THREAD_ATTACH o DLL_THREAD_DETACH.)

Si fdwReason es DLL_PROCESS_ATTACH, esto es nada para las bibliotecas cargadas dinámicamente utilizando funciones como LoadLibrary y GetProcAddress, y no es nada para las bibliotecas de carga estática por talones de la colección de proporcionar en tiempo de compilación. Si fdwReason es DLL_PROCESS_DETACH, no es nada si la llamada es el resultado de una llamada a la función de Win32 FreeLibrary, y no es nada si el punto de entrada se llama durante la terminación del proceso.

El valor de retorno de la función sólo tiene sentido si es fdwReason DLL_PROCESS_ATTACH. Si la inicialización se realiza correctamente, la función debe devolver True, de lo contrario, debe devolver false. Tenga en cuenta que debido a que la función es un punto de entrada llamada por Windows, los valores de los argumentos pasados a la función son proporcionados por Windows. Además, el punto de

entrada no se llama cuando un hilo se termina con la función de Win32 TerminateThread, ni se llama cuando un proceso se termina con la función de Win32 TerminateProcess.

El valor de retorno de la función sólo tiene sentido si es fdwReason DLL_PROCESS_ATTACH. Si la inicialización se realiza correctamente, la función debe devolver True, de lo contrario, debe devolver false. Tenga en cuenta que debido a que la función es un punto de entrada llamada por Windows, los valores de los argumentos pasados a la función son proporcionados por Windows. Además, el punto de entrada no se llama cuando un hilo se termina con la función de Win32 TerminateThread, ni se llama cuando un proceso se termina con la función de Win32 TerminateProcess.

El Código DLL

En el intento de desarrollar una DLL de Windows, vamos a crear una biblioteca muy simple de funciones matemáticas. El siguiente es el código del archivo DLL, que vamos a almacenar en un módulo de código (un archivo bas.) llamado MathLib:

Option Explicit

Public Const DLL_PROCESS_DETACH = 0Public Const DLL_PROCESS_ATTACH = 1Public Const DLL_THREAD_ATTACH = 2Public 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 SelectEnd Function

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

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

Public Function Square(var As Long) As Long If Not IsNumeric(var) Then Err.Raise 5 Square = var ^ 2End Function

varias características sobre el código vale la pena mencionar. La primera es que a pesar de que incluye un procedimiento DllMain, ningún proceso o por la inicialización por subproceso debe realizarse. Así DllMain simplemente devuelve True si se le llama con el argumento de fdwReason establece DLL_PROCESS_ATTACH.

En segundo lugar, el punto de proporcionar un archivo DLL de Windows es permitir a otros idiomas para llamarlo. Para garantizar la interoperabilidad, queremos limitarnos a las características del lenguaje que la API de Win32 admite, por lo que nuestra DLL se puede llamar desde los entornos de desarrollo y muchas plataformas como sea posible. Podríamos haber hecho cada uno de nuestros tres funciones matemáticas más flexible, por ejemplo, mediante la definición tanto en el argumento de entrada y el valor de retorno como variantes. Eso habría permitido a la función para determinar el tipo de datos se deben interpretar los datos de entrada como, además del tipo de datos se debe devolver. Sin embargo, la variante es un tipo de datos definidos por el COM, de componentes de Microsoft Modelo de objetos, y no es un tipo de datos de la API Win32 reconoce. Así que en lugar, el código utiliza el estándar de Win32 API de tipos de datos.

También necesitará un programa de prueba que nos diga si nuestra DLL de Windows funciona correctamente. Para ello, se puede crear un proyecto EXE estándar con una forma y un módulo de código. El módulo de código consiste simplemente en las instrucciones Declare que definen las funciones que se encuentran en el archivo 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

En lugar de simplemente especificando el nombre del archivo DLL en la cláusula Lib, también debe agregar la ruta completa al directorio que contiene el archivo DLL.

El código del formulario realiza las llamadas a las funciones DLL:

Option Explicit

Dim incr As IntegerDim decr As IntegerDim sqr As Long

Private Sub cmdDecrement_Click() decr = Increment(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(srr)

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

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

El DLL de ActiveX Tipo de Proyecto

Comencemos por crear un proyecto DLL ActiveX y ver lo que ocurre si tratamos de llamar como si fuera una norma DLL de Windows. Al crear un proyecto DLL ActiveX, Visual Basic agrega automáticamente un módulo de clase (un archivo. cls) a la misma. Puede cambiar el nombre si desea, pero no incluye ningún código. En su lugar, agregue un módulo de código (un archivo. BAS) para el proyecto, agregar el código del archivo DLL y, a continuación, compile la DLL. Al ejecutar la aplicación de prueba DLL, el diálogo de mensaje de error que se muestra en la Figura 1 aparece. El mensaje de error indica que, aunque se encontró el archivo DLL, la función específica llamada (incremento) no lo era.

Figura 1. Error al acceder a un archivo DLL de ActiveX como un archivo DLL de Windows

La causa más probable de este error es que la función no es exportadas por la DLL. Podemos utilizar la utilidad DUMPBIN para examinar las exportaciones de un archivo DLL mediante el uso de la sintaxis

Dumpbin <path and name of dll> /exportsSi corremos DumpBin utilizando esta sintaxis, podemos ver el siguiente resultado:

Microsoft (R) COFF Binary File Dumper Version 6.00.8447Copyright (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

Nuestras exportaciones DLL cuatro funciones, todas las cuales son las funciones de utilidad que soporte COM. Es evidente que necesitamos para exportar DllMain y nuestros tres funciones matemáticas. Pero, ¿cómo? Visual Basic no parece que le permiten exportar funciones DLL de ActiveX DLL, por lo que efectivamente le impide el uso de Visual Basic para crear un estándar DLL de Windows.

Esta dificultad, sin embargo, no es insuperable. Cuando se selecciona el menú Archivo -.> Crear <filename> opción de menú dll para crear un archivo DLL de ActiveX, parece que Visual Basic es la perfección de tomar nuestro código fuente y la salida de un archivo DLL de ActiveX. Pero si examinamos el subdirectorio en el que Visual Basic se ha instalado, parece que el proceso no es tan perfecta. Junto con VB6.exe, el ejecutable de Visual Basic que define el entorno de Visual Basic, también podemos encontrar C2.EXE y LINK.EXE, que es un compilador y un enlazador, respectivamente. Su presencia en este directorio sugiere que VB6.exe no se ocupa por si mismo de la generación de la DLL, pero que en algún momento en el proceso de compilación, se llama a estos programas.

Podemos encontrar la manera de Visual Basic utiliza el compilador y enlazador más precisamente cambiando el nombre de ellos y crear ejecutables contenedor llamado C2 y LINK que a su vez llamar al compilador y enlazador real. El siguiente es el código fuente de una nueva versión de un C2.EXE consola de modo que llama a la "real" del compilador C2, que hemos cambiado el nombre C2comp.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

El proceso de implantación de un archivo DLL ActiveX produce la siguiente salida en nuestro archivo de registro:

Beginning execution at 12/10/2004 12:44:22 PM

Command line parameters to c2 call: -il "C:\DOCUME~1\Ron\LOCALS~1\Temp\VB277103" -f "C:\VB Projects\ MathLib\MathMod.bas" -W 3 -Gy -G5 -Gs4096 -dos -Zl -Fo"C:\ VB Projects\MathLib\MathMod.OBJ" -QIfdiv -ML -basic

Calling C2 compiler

Returned from c2 compiler call

Estos argumentos son bastante estándar de línea de comandos para generar archivos objeto que a su vez se suministran al vinculador. Eso significa que para determinar la manera de producir un archivo DLL de Windows, vamos a tener que interceptar la llamada al enlazador para que podamos ver lo que los argumentos de Visual Basic pasa a ella. El siguiente código hace lo siguiente:

Public Sub Main ()

On Error Resume Next

    Dim strCmd As String, strPath As String    Como Scripting.FileSystemObject Dim OFS Nuevo    Dim ts Como TextStream

    strCmd = Comando       strPath = App.Path       Establecer ct = oFS.CreateTextFile (strPath & "\ lnklog.txt")       ts.WriteLine "A partir de la ejecución en"& Fecha & ""& Time ()    ts.WriteBlankLines un    ts.WriteLine "parámetros de la línea de comandos para llamar a LINK:"    "ts.WriteLine" y strCmd    ts.WriteBlankLines un    ts.WriteLine "Calling vinculador LINK"       Shell "linklnk.exe" y strCmd    Si <Err.Number> 0 Then       ts.WriteLine "Error en el vinculador llamando ..."       Err.Clear    End If       ts.WriteBlankLines un    ts.WriteLine "devolución de llamada del vinculador"    ts.Close   End Sub

Se requiere que cambie el nombre del LinkLnk.exe enlazador y el nombre de nuestro Link.exe contenedor enlace.Cuando tratamos de elaborar un proyecto DLL ActiveX, nuestro archivo de registro vinculador contiene el siguiente resultado:

Beginning execution at 12/11/2004 12:44:33 PM

Command line parameters to LINK call: "C:\Program Files\Microsoft Visual Studio\VB98\Class1.OBJ" "C:\Program Files\Microsoft Visual Studio\VB98\Project1.OBJ" "C:\Program Files\Microsoft Visual Studio\VB98\VBAEXE6.LIB" /ENTRY:__vbaS /OUT:"C:\Program Files\Microsoft Visual Studio\VB98\Project1.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 comparamos estos argumentos de la línea de comandos con la sintaxis necesaria para vincular los archivos objeto de una DLL usando C o C + +, una omisión se hace inmediatamente evidente. Aunque el modificador / DLL se suministra para crear un archivo DLL estándar, no hay modificador / DEF para definir una definición de módulo (. def) del archivo que se enumeran las funciones exportadas por la DLL. (Si se programa en C o C + +, podemos utilizar las declaraciones dentro de nuestro código para definir nuestras exportaciones. Visual Basic no es compatible con esto, sin embargo, por lo que la definición de archivo. el único medio de la definición de las exportaciones de la biblioteca.) Por otra parte, si examinamos los archivos generados por un proyecto DLL ActiveX por el entorno de Visual Basic, también encontrará que Visual Basic no se ha generado un archivo de definición..

Creación de la DLL de Windows

Así, después de examinar la tabla un archivo DLL de ActiveX de exportación, interceptar llamadas de Visual Basic para el compilador, interceptar llamadas de Visual Basic para el enlazador, y la comparación de los argumentos pasados al vinculador con las exigidas a C / C + + para generar un archivo DLL de Windows, Por fin has identificado por las que no son capaces de crear con éxito un archivo DLL de Windows con Visual Basic. Y afortunadamente, podemos evitar esa restricción. Debemos ser capaces de crear un estándar de archivo DLL de Windows si no hacemos lo siguiente:

1. Cree un archivo. def para nuestro proyecto. Podemos especificar nuestras funciones exportadas en el archivo de definición de varias maneras, pero lo mejor es mantenerlo simple.:

NAME MathLibLIBRARY MathModDESCRIPTION "Add-on Library of Mathematical Routines"EXPORTS DllMain @1 Increment @2 Decrement @3 Square @4

La instrucción NAME define el nombre de la DLL. La instrucción LIBRARY o debe preceder a la lista de funciones exportadas o aparecer en la misma línea que la primera función. El archivo de definición. También se enumerarán la posición ordinal de cada función exportada precedido por un símbolo @.

2 Decidir cómo queremos para interceptar la llamada al enlazador. Dos técnicas principales son disponibles para hacer esto:

El parcheo de las importaciones de tabla de dirección (IAT), que exige que se construye un Visual Basic complemento que modifica el TAI con el fin de interceptar llamadas en particular por Visual Basic para la API de Win32. Aunque es sin duda el método más elegante, su complejidad hace que sea un tema digno de un artículo separado.

La construcción de un enlazador proxy que intercepta la llamada al enlazador real, modifica los argumentos de línea de comandos para pasar al enlazador, y luego llama al enlazador con los argumentos correctos de línea de comandos. Este es el enfoque que utiliza para descubrir lo que los argumentos de Visual Basic se pasa al compilador y enlazador, y es el enfoque que va a adoptar para crear un archivo DLL de Windows.

En la construcción de nuestro enlazador proxy, queremos un diseño lo suficientemente flexible para que podamos generar otros tipos de archivos, en caso necesario.

3 Modificar los argumentos para el enlazador para agregar el / DEF interruptor junto a la ruta y el nombre de nuestro archivo def.. Para ello, debe crear un estándar de Visual Basic proyecto EXE, agregue una referencia al Microsoft Scripting Runtime Library, quitar el formulario del proyecto, y añadir un módulo de código. El código fuente para el enlazador proxy es la siguiente:.

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.CloseEnd Sub

Este vinculador proxy modifica sólo los argumentos de línea de comandos se pasa al vinculador si un archivo de definición está en el directorio que contiene el proyecto de Visual Basic;. de lo contrario, simplemente pasa los argumentos de línea de comandos en el enlazador sin cambios. Si un archivo de definición. está presente, se agrega un modificador / DEF para la línea de comandos. También se determina si los archivos de recursos se van a agregar a la lista de archivos vinculados. Por último, examina la tabla de exportación para determinar si una función llamada CPlApplet está presente, si es así, cambia la extensión del archivo de salida es de dll para cpl...    4.

       Para instalar el enlazador proxy, cambiar el nombre original de Visual Basic vinculador LinkLnk.exe, copie el enlazador proxy en el directorio de Visual Basic, y el nombre de Link.exe.

Una vez que creemos nuestro enlazador proxy, que puede volver a cargar nuestro proyecto MathLib y compilarlo en un archivo DLL seleccionando la opción Hacer MathLib.exe en el menú Archivo.

Prueba de la DLL

Una vez que creemos nuestro DLL de Windows, el paso final es poner a prueba para asegurarse de que funciona. Para ello, cree un nuevo proyecto EXE estándar (llamémosla MathLibTest) y añadir un

módulo de código. Para asegurarse de que el código en nuestro proyecto se puede acceder a las funciones exportadas por la DLL, se utiliza el estándar de Visual Basic instrucción Declare. Declaramos nuestros tres exportados rutinas matemáticas en el módulo de código de la siguiente manera:

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

A continuación, puede utilizar el código siguiente en el módulo de formulario para llamar a las rutinas en el archivo DLL:

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 = 2End Sub

Cuando llamamos a cada una de las funciones MathLib, la ventana de la aplicación puede aparecer como lo hace en la figura 2, lo que confirma que las llamadas a las rutinas MathLib funciona como se esperaba.