¿Cómo llamar el código de función desde el programa principal en Delphi, escribirlo en la "DLL" y llamarlo?
Hermano, ¿delphi2007 es genuino o una versión pirateada? ¿Dónde lo conseguiste? ¿Usted pude decirme?
1. Inicie su primer proyecto DLL
1.Archivo->Cerrar todo->Archivo->Nuevo［DLL］
Código:
//El código se genera automáticamente de la siguiente manera
biblioteca Project2
//Esto no tiene sentido
usa
SysUtils ,
Clases;
{$R *.RES}
inicio
fin.
2. Agregue una función:
Código:
biblioteca Proyecto2
usa
SysUtils,
Clases; /p>
Función MyMax ( X , Y : entero ) : entero ; stdcall
comenzar
si X > Y entonces
Resultado := , pero el caso de DLL-Func es relevante.
// MyMax escrito en DLL-Func-Name es diferente de myMAX. Si lo escribe mal, el resultado inmediato
// es que el AP al que llamó usando esta DLL no se puede abrir en absoluto.
//No importa el caso de los parámetros. Ni siquiera tiene que ser el mismo nombre. Si el prototipo es (X,Y:integer) pero la referencia
// está escrita como (A,B:integer), está bien.
//Recuerda: agrega otra llamada estándar. Según el libro, si está escribiendo una DLL en Delphi y desea usarla no sólo para
// Delphi-AP sino también para BCB/VC-AP, etc., entonces será mejor que agregue una directiva Stdcall ;
//Tipo de parámetro: Delphi tiene muchos tipos de variables propias, que ciertamente no son las que le gustan a DLL.
// El idioma nativo de Windows/ La DLL debe ser C. Entonces, si queremos pasar parámetros dentro y fuera de la DLL,
// los usamos de acuerdo con las reglas tanto como sea posible. Al escribir los dos, el último causará muchos problemas. Si no está familiarizado con C
//, está bien. Hablaremos de eso más tarde.
{$R *.RES}
inicio
fin.
3. Regala estas funciones que se pueden disfrutar DLL, deje que el mundo exterior (es decir, su Delphi-AP) lo use: así, su AP no puede usarlos, necesita agregar Exportaciones.
Código:
{$R *.RES}
exportaciones
MyMax
inicio
p>
p>
fin.
4. Bien, puedes presionar Ctrl-F9 para compilar. No presione F9 en este momento. DLL no es un EXE y no se puede ejecutar solo. Si presiona F9, aparecerá un mensaje de error. Si hay un error en la DLL en este momento, corríjalo. Presione Ctrl-F9 nuevamente. Puede haber una Advertencia en este momento, no importa, solo investiga un poco y verás. Presione Ctrl-F9 nuevamente y estará "Listo, compilado". Habrá un *.dll en el mismo directorio. Felicitaciones, ya terminaste.
2. Prueba: Abra una nueva aplicación:
1. Agregue un TButton
Código:
ShowMessage ( IntToStr(MyMax ( 30,50)) ) ;
2. Dígale a Exe dónde tomar un código Func
:
//Agregar después de Formulario, interfaz, var
Función MyMax ( /p>
// El caso del nombre de la DLL no importa. Pero recuerda agregar la extensión .DLL. En Win95 o NT,
// No es necesario agregar extensiones, pero en estos dos sistemas operativos, puede ser cada vez menos. Simplemente agrega la extensión
Eso es todo, es fácil.
¿El ejemplo anterior es muy sencillo? Los amigos que están familiarizados con Delphi pueden ver que el código anterior es básicamente el mismo que escribir un programa Delphi general, excepto que hay un parámetro stdcall adicional después de la función TestDll y la función TestDll se declara con la declaración de exportaciones. Siempre que compile el código anterior, puede abrir la biblioteca de enlaces dinámicos de elphi.dll. Ahora, echemos un vistazo a lo que se debe prestar atención:
1. Todas las funciones o procedimientos escritos en DLL deben agregar parámetros de llamada stdcall. En el entorno Delphi 1 o Delphi 2, el parámetro de llamada está lejos. Desde Delphi 3 en adelante, este parámetro se cambió a stdcall para utilizar la tecnología de paso de parámetros estándar de Win32 en lugar del parámetro de registro optimizado. Olvidar usar el parámetro stdcall es un error común. Este error no afectará la compilación y generación de la DLL, pero ocurrirá un error grave cuando se llame a la DLL, lo que provocará un bloqueo en el sistema operativo. La razón es que el parámetro de registro es el parámetro predeterminado de Delphi.
2. Las funciones y procedimientos escritos deben declararse como funciones externas utilizando la declaración exports.
Como puedes ver, la función TestDll está declarada como una función externa. Hacer esto permite que la función sea visible externamente. El método específico es hacer clic con el botón derecho del mouse y usar la función "Vista rápida" para ver el archivo DLL. (Puede realizar la instalación desde el CD de Windows si no tiene la opción Vista rápida). La función TestDll aparecerá en la columna Exportar tabla. Otra buena razón es que si no lo declaramos así, la función que escribimos no será llamada, algo que nadie quiere ver.
3. Cuando se utilizan parámetros y variables de tipo cadena larga, se debe citar ShareMem.
El tipo de cadena en Delphi es muy poderoso. Sabemos que la longitud máxima de una cadena ordinaria es de 256 caracteres, pero la longitud del tipo de cadena en Delphi puede alcanzar 2G de forma predeterminada. (Sí, leíste bien, de hecho son dos megabytes). En este momento, si insistes en usar parámetros de tipo cadena, variables o incluso registrar información, debes hacer referencia a la unidad ShareMem, y debe ser la primera citada. Después de la declaración de usos está la primera unidad a la que se hace referencia. Por ejemplo:
usa
ShareMem,
SysUtils,
Classes;
Una cosa más, en El mismo trabajo debe realizarse en el archivo de su proyecto (*.dpr) en lugar del archivo de la unidad (*.pas). Esto no queda claro en el archivo de ayuda que viene con Delphi, lo que provoca muchos malentendidos. Si no hace esto, es probable que pague el precio. La forma de evitar el uso del tipo cadena es declarar parámetros, variables, etc. de tipo cadena como tipo Pchar o ShortString (como: s:string[10]). El mismo problema ocurre cuando usa matrices dinámicas y la solución es la misma que la anterior.
Llamada estática de DLL en Delphi arriba
Llamar a una DLL es más fácil que escribir una DLL. Primero, les presentaré el método de llamada estática. Luego, presentaré el método de llamada dinámica y haré una comparación entre los dos métodos. De manera similar, primero demos un ejemplo de llamadas estáticas.
unidad Unidad1;
interfaz
usa
Windows, Mensajes, SysUtils, Clases, Gráficos,
Controles, Formularios, Diálogos, StdCtrls;
tipo
TForm1 = clase(TForm)
Editar1: TEdit
Botón1: TButton; ;
procedimiento Button1Click(Remitente: TObject
privado
{ Declaraciones privadas }
público
{ Declaraciones públicas }
end;
var
Form1: TForm1
implementación
{$R *.DFM}
//El siguiente código en esta línea es el código que realmente escribimos
function TestDll(i:integer):integer;stdcall
procedimiento TForm1.Button1Click(Remitente: TObject
comenzar
Edit1.Text:=IntToStr(TestDll(1); ) );
end;
end.
En el ejemplo anterior, colocamos un cuadro de edición (Editar) y un botón (Botón) en el formulario. y escribí muy poco código para probar el Delphi.dll que acabamos de escribir. Como puede ver, el único trabajo que hicimos fue colocar la parte de descripción de la función TestDll en la implementación y usar la declaración externa para especificar la ubicación de Delphi.dll. (En este ejemplo, el programa que llama y Delphi.dll están en el mismo directorio). Lo interesante es que Delphi reconoció rápidamente la función TestDll que escribimos. Puede hacer este experimento: ingrese "TestDll(", y pronto Delphi usará una barra de aviso para indicarle qué parámetros debe ingresar, tal como usamos otras funciones definidas en Delphi. Las cosas a tener en cuenta son las siguientes: Algunas:
1. Utilice stdcall para llamar a parámetros
Como se mencionó anteriormente, los parámetros stdcall también deben usarse al hacer referencia a funciones y procedimientos en la DLL. Las razones son las mismas que las mencionadas anteriormente.
2. Utilice la declaración externa para especificar la ruta y el nombre del archivo DLL que se llamará.
Como puede ver, especificamos la ruta y el nombre del archivo DLL. para ser llamado en la declaración externa Nombre La ruta no está escrita porque el archivo DLL y el programa principal que lo llama están en el mismo directorio. Si el archivo DLL está en C:\, podemos escribir la declaración de referencia anterior como. externo 'C:\Delphi.dll'. Tenga en cuenta que el sufijo del archivo .dll debe escribirse
3. Las variables globales no se pueden llamar desde la DLL
. tipo de variable global en la DLL, como: var s: byte De esta manera, la variable global s se puede usar normalmente en la DLL, pero el programa que llama no puede usar s y s no se puede pasar al que llama. programa como una variable global Sin embargo, las variables declaradas en el programa de llamada se pueden pasar a la DLL como parámetros
4. La DLL llamada debe existir
Esto es muy importante. Al utilizar el método de llamada estática, el archivo DLL que se llama y la función o proceso a llamar deben existir. Si no existe o la ruta especificada y el nombre del archivo son incorrectos, el sistema mostrará "Error al iniciar el programa" o "No se puede encontrar". *.dll" cuando se ejecuta el programa principal.
En Delphi. Llamar dinámicamente a DLL top
Llamar dinámicamente a DLL es relativamente complicado, pero es muy flexible. Para explicarlo completamente Para solucionar el problema, esta vez damos un ejemplo de cómo llamar a una DLL escrita en C++. Primero, compila lo siguiente en el programa fuente DLL.
#include
extern ”C” _declspec(dllexport)
int WINAPI TestC(int i)
{
return i;
}
Después de la compilación, se genera un archivo DLL. Aquí llamamos al archivo Cpp.dll. Solo hay una función TestC en este DLL. un tipo entero. Para facilitar la explicación, todavía citamos el programa de llamada anterior, pero reemplazamos las declaraciones originales en el proceso Button1Click con el siguiente código.
procedimiento TForm1.Button1Click(Sender: TObject);
tipo
TIntFunc=function(i:integer):integer;stdcall //Eliminar el dll El nombre de la función puede ser
var
Th:Thandle
Tf:TIntFunc
Tp:TFarProc
;comenzar
Th:=LoadLibrary('Cpp.dll'); {Cargar DLL}
si Th>0 entonces
intenta
Tp:=GetProcAddress(Th,PChar('TestC'));
si Tp<>nil
entonces comienza
Tf:= TIntFunc(Tp);
Edit1.Text:=IntToStr(Tf(1)); {Llamar a la función TestC}
end
else
ShowMessage('Función TestC no encontrada');
finalmente
FreeLibrary(Th); {Liberar DLL}
fin
else
ShowMessage('Cpp.dll not found');
end;
Como has visto, esta tecnología de llamadas dinámicas es muy complicada. Pero siempre que se modifiquen los parámetros, como modificar el nombre de la DLL en LoadLibrary ('Cpp.dll') a 'Delphi.dll', la DLL llamada se puede cambiar dinámicamente.
1. Definir el tipo de función o procedimiento a llamar
En el código anterior definimos un tipo TIntFunc, que corresponde a la función TestC que vamos a llamar. El mismo trabajo de definición debe realizarse en otras situaciones de llamada. Y también agregue parámetros de llamada stdcall.
2. Libere la DLL llamada
Usamos LoadLibrary para llamar dinámicamente una DLL, pero recuerde que debe usar FreeLibrary manualmente para liberar la DLL después de su uso. hasta que salga de Windows o apague la computadora.
Ahora evalúemos las ventajas y desventajas de los dos métodos de llamar a DLL. El método estático es simple de implementar, fácil de dominar y, en general, un poco más rápido, más seguro y confiable; sin embargo, el método estático no puede descargar de manera flexible la DLL requerida en tiempo de ejecución, sino que carga la DLL especificada cuando el programa principal comienza a ejecutarse. La DLL se publica sólo cuando finaliza el programa. Además, sólo los sistemas basados en compiladores y enlazadores (como Delphi) pueden utilizar este método. El método dinámico resuelve mejor las deficiencias del método estático y puede acceder fácilmente a las funciones y procedimientos en la DLL, e incluso a algunas funciones o procedimientos recién agregados en la versión anterior de la DLL; sin embargo, el método dinámico es difícil de dominar por completo; , Debido a diferentes funciones o procedimientos, es necesario definir muchos tipos complejos y métodos de llamada. Para los principiantes, el autor recomienda que utilicen métodos estáticos y luego utilicen métodos de llamada dinámica una vez que dominen.
Consejos prácticos para usar DLL top
1. Habilidades de escritura
1. Para garantizar la exactitud de la DLL, se puede escribir como parte de primero una aplicación normal y luego sepárela del programa principal después de que la depuración sea correcta y compílela en una DLL.
2. Para garantizar la versatilidad de la DLL, debe evitar los nombres de los controles visuales en la DLL que escriba, como el nombre Edit1 en Edit1.Text o personalizar los no definidos por Windows; tipos, como Algún tipo de registro.
3. Para facilitar la depuración, cada función y proceso debe ser lo más breve y conciso posible, con comentarios específicos y detallados.
4. Utilice try-finally para manejar posibles errores y excepciones, y asegúrese de hacer referencia a la unidad SysUtils en este momento.
5. Haga referencia a las unidades lo menos posible para reducir el tamaño de la DLL, especialmente no haga referencia a unidades visuales, como las unidades de Diálogos. Por ejemplo, en circunstancias normales, no podemos hacer referencia a la unidad Clases, lo que puede reducir la DLL compilada en aproximadamente 16 Kb.
2. Habilidades de llamada
1. Al utilizar métodos estáticos, puede cambiar el nombre de la función o procedimiento llamado. En el ejemplo de DLL escrito en C++ antes mencionado, si se elimina la declaración externa "C", C++ compilará algunos nombres de funciones extraños. La función TestC original se llamará @TestC$s y otros nombres ridículamente extraños. Esto se debe a que C++ usa C++. tecnología de manipulación de nombres. Este nombre de función es ilegal en Delphi. Podemos resolver este problema de esta manera:
Reescribe la función de referencia en
función TestC(i:integer):integer;stdcall
externo 'Cpp.dll';nombre '@TestC$s';
La función del nombre es cambiar el nombre.
2. La DLL que escribimos se puede colocar en el directorio de Windows o en el directorio Windows\system. Esto se puede hacer no escribiendo la ruta sino solo el nombre de la DLL en la declaración externa o en la declaración LoadLibrary. Pero hay algo mal en esto. Hay una gran cantidad de DLL importantes del sistema en estos dos directorios. Si la DLL que escribe tiene el mismo nombre, las consecuencias serán desastrosas. Además, sus habilidades de programación no son suficientes. ¡La DLL que escribiste está en el directorio del sistema!
3. Habilidades de depuración
1. Sabemos que la DLL no se puede ejecutar ni depurar en un solo paso al escribir. Una forma de hacerlo es configurar un programa host en el menú Ejecutar|parámetros. Agregue el nombre del programa host en la columna Aplicación host de la página Local para realizar la depuración, la observación de puntos de interrupción y la operación en un solo paso.
2. Agregue información de la versión de DLL. Las palabras de apertura mencionaron que la información de la versión es muy importante para la DLL. Si se incluye información de la versión, el tamaño de la DLL aumentará en 2 Kb. El espacio extra merece la pena. Desafortunadamente, no es posible utilizar directamente la opción Versión en el menú Proyecto|opciones. Esto no se menciona en el archivo de ayuda de Delphi. Después de la investigación, el autor descubrió que todo lo que se necesita es agregar una línea de código. Tomemos el siguiente ejemplo:
Cuando compilamos el programa con Delphi y nos preparamos para lanzar el producto, siempre queremos publicar información personalizada con el producto para indicar la fuente del producto.
Además de la información del desarrollador y de otro tipo, como Es lo mismo que los programas de Windows, podemos decir que es un producto de Microsoft con solo mirar sus atributos. Ahora le mostraré cómo agregar información de versión a archivos exe y dll.
VS_VERSION_INFO VERSIONINFO //Estructura de información de la versión
FILEVERSION 1,0,0,1 //Como su nombre lo indica, la versión del archivo se muestra en la página de propiedades version|
PRODUCTVERSION 1,0,0,1 //Como sugiere el nombre, versión del producto|Aquí está la información principal de la versión
FILEFLAGSMASK 0x3fL //Simplemente configúrelo en 0x3fL aquí|
#ifdef _DEBUG
FILEFLAGS 0x1L //VS_FF_DEBUG incluye información de depuración
#else
FILEFLAGS 0x0L //Ninguno
# endif
FILEOS 0x4L //Corresponde a VOS__WINDOWS32 en Delphi, lo que indica que el programa es un programa win32
FILETYPE 0x2L //Tipo de archivo, $2 es dll, $1 es exe
FILESUBTYPE 0x0L // Tipo de subtipo de archivo, generalmente establecido en 0
BEGIN
BLOCK StringFileInfo //Establezca aquí otra información de versión (detalles) del archivo
BEGIN
BLOQUE 080403A8 //Idioma 080403A8 Chino simplificado, 040904b0 Inglés (Estados Unidos)
BEGIN
VALOR Comentarios, prueba de mi aplicación Dll // Observaciones
VALUE CompanyName, JJony\0 //Nombre de la empresa
VALUE FileDescription, xxx.dll\0 //Descripción del producto
VALUE FileVersion, 1. 0 0. 1\0 // Versión del archivo
VALOR Nombre interno, // Nombre interno
VALOR LegalCopyright, Copyright (C) 2006.6\0 //Información de derechos de autor
VALUE OriginalFilename, xxx.dll \0 //Nombre del archivo fuente
VALUE ProductName, xxx.dll\0 //Nombre del producto
VALUE ProductVersion, 1. 0. 0. 1\0 //Versión del producto
FIN
FIN
BLOQUEAR VarFileInfo
BEGIN
VALOR Traducción, 0x804, 0x03A8 //Aquí está la clave Oh, ya está decidido qué idioma es
END //0x0804, 0x03A8 Chino simplificado
END //0x0409, 0x04b0 Inglés (Estados Unidos)
Una forma más sencilla de agregar la información de la versión de una DLL es:
Primero agregue la información de la versión completa de un programa que quiera hacer referencia al archivo dll y luego copie el Project1.res del programa al directorio de archivos donde se generará el dll, y cámbiele el nombre a aa.res, luego cree un dll, cambie "biblioteca Project1" en el editor de dll a "biblioteca aa", agregue "{ $R *.res}", compilar y aceptar.
3. Para evitar la duplicación de nombres con otras DLL, es mejor utilizar una combinación de letras, números y guiones bajos al nombrar la DLL que escribe. Por ejemplo: jl_try16.dll.
4. Si ha compilado alguna DLL en Delphi 1 o Delphi 2, la DLL que compiló originalmente es de 16 bits.
Siempre que el código fuente se vuelva a compilar en el nuevo entorno Delphi 3 o Delphi 4, puede obtener una DLL de 32 bits.
[Posdata]: Además de los métodos más utilizados para usar DLL presentados anteriormente, las DLL también se pueden utilizar como portadores de recursos. Por ejemplo, cambiar iconos en Windows utiliza recursos en una DLL.
Además, dominar la tecnología de diseño de DLL tendrá muchos beneficios al utilizar programación OLE, COM y ActiveX más avanzada.