INFO: DLL's, BPL's, carga dinámica, carga estática y Packages en Runtime

[Neftali [Germán.Estévez]]

Es un tema que ya ha salido otras veces, y son muchas "palabrejas"; Al principio (a mi me pasó también) uno se lía un poco, así que ya que he escrito la explicación para un hilo concreto de estos foros, creo que es mejor publicarla aquí por si a alguien más le puede interesar.


DLL's, BPL's, carga dinámica, carga estática y Packages en Runtime

Sí ya se que el título es un poco largo... ;-)
Para aclarar un poco las cosas intentare explicar todos los casos que a mí se me ocurren, cómo configurarlos y lo que se puede hacer con ellos, de forma rápida; Aclararemos antes la opción "Build With Runtime Package" imprescindible para TODO esto:

·······························································································
BWRP = "Build with runtime packages"
Esta opción se encuentra en las "opciones de proyecto" y con ella conseguimos:

* ACTIVADA: El programa no incluye las librerías (normalmente la VCL y componentes de terceros) en el EXE; El ejecutable es más pequeño, pero necesita de los packages (BPLs) de la VCL; Al distribuir la aplicación se deben copiar también esos ficheros (los necesarios).
* DESACTIVADA: El programa incluye en el EXE los packages de librerías y componentes de terceros. En 1 sólo fichero va todo incluído. El EXE tiene mayor tamaño (lógico porque todo va incluído).
·······························································································

* EXE + DLL carga estática(El EXE puede ser con o sin BWRP)
La DLL debe existir cuando se ejecuta la aplicación, de otra forma esta no funcionaría.
Hay que definir dónde se encuentra la DLL (en el que la carga) y con eso ya se puede hacer la llamada:

Código Delphi [-]
function Sumar(x,y:integer):Integer; stdcall; external 'sumas.dll';

Código Delphi [-]
Res := Sumar(4,5);

* EXE + DLL carga dinámica(El EXE puede ser con o sin BWRP)
En este caso el programa puede funcionar aunque la DLL no exista; En el momento de intentar cargarla se debe comprobar si está o no. Se utiliza para programas que cargan plugins o similares. La carga es un poco más compleja.
Se utiliza LoadLibrary para cargar la DLL en el momento en que se necesita:

Código Delphi [-]
  H := LoadLibrary('SUMAS.DLL');

Para acceder a las funciones de la DLL se usa GetProcAddress:

Código Delphi [-]
  @sum := GetProcAddress(H, 'Sumar2');

Tiene que estar predefinido el tipo de la función en el programa donde se llama:

Código Delphi [-]
  Sum: function(x,y:Integer):integer; stdcall;

* EXE + BPL carga estática(El EXE puede ser con o sin BWRP)
En este caso no hace falta definir nada referente a la función que se encuentra en el package, simplemente hacer referencia a ella en diseño.
Si el programa se compila con "BRWP Desactivado" TODO va dentro del EXE. Si se compila con "BWRP activado" la BPL va aparte, pero es obligatorio que exista, ya que la carga se ha hecho de forma estática (en diseño hemos añadido un USES); Si la BPL no existe el programa no puede funcionar.
Para trabajar así basta con añadir al USES las units del packages que necesitemos.

* EXE + BPL carga dinámica + RTTI(El EXE debe ser con BWRP)
Es el caso más potente que tenemos. Cargar BPL's (que son más potentes que las DLL's) de forma dinámica. Para ello hacemos uso de RTTI (Runtime Type Information) que es lo que le da la potencia extra a los BPL's. En obligatorio en este caso que "BWRP esté activado"; Es decir, obligatoriamente debemos distribuir nuestra aplicación con packages.
Los packages se cargan de forma dinámica con LoadPackage:

Código Delphi [-]
  H := LoadPackage('RESTAS.BPL');

Podemos acceder a las funciones de la misma forma que lo hacemos con las DLL's, utilizando GetProcaddress:

Código Delphi [-]
  @resta := GetProcAddress(H, 'Resta');

Podemos utilizar RTTI para acceder a classes que previamente se han registrado (con RegisterClass) utilizando funciones de RTTI como GetClass:

Código Delphi [-]
    AClass := GetClass('TFormMain');

Y podemos acceder a métodos de las clases utilizando también RTTI, utilizando MethodAddress:

Código Delphi [-]
      // Acceder al método
      Routine.Data := Pointer((F as FormClass));
      // Ejecutar al código
      Routine.Code := (F as FormClass).MethodAddress('ExecForm');

* EXE + BPL carga dinámica sin RTTI(El EXE puede ser sin BWRP)
Hay una última opción (un poco rara), que sería uriliar un EXE con "BRWP Desactivado" (es decir TODO en un único EXE) y cargar en él package de forma dinámica. Esto es posible, pero en este caso perdemos la opción de utilizar RTTI; El EXE (fichero único) podría funcionar sin que exista la BPL que vamos a cargar. Esta opción, aunque es viable, como digo, no tiene mucho sentido, porque utiliza las BPL como si se trataran de DLL; Al no poder utilizar RTTI, las "mejoras" que tienen las BPL's se pierden y pasan a usarse como DLL's.

Se pueden cargar las BPL's de forma dinámica con LoadPackage:

Código Delphi [-]
  H := LoadPackage('RESTAS.BPL');

Y para acceder a las funciones usamos GetProcAddress (como en las DLL's):

Código Delphi [-]
  @resta := GetProcAddress(H, 'Resta');

Por supuesto si intentamos acceder a información de clases (GetClass) el programa falla.

Espero que este "breve" explicación haya servido para aclarar alguna cosa. Si tengo un hueco itentaré colgar los ejempos correspondientes a cada caso.

Un salduo.

[roman]

Una pregunta:

Cuando activas la opción "Buld with runtime packages", ¿qué papel juegan los paquetes listados en el cuadro de edición adjunto?

// Saludos

[Neftali [Germán.Estévez]]

Con ese Edit estás obligando (o indicando) a que ese package realmente sea un package en Runtime; No se van añadir al programa principal.

Imagina la siguiente situación; En un mismo directorio tienes los ficheros del package (Restas.BPL) y del Ejecutable (EXE).
Borras todos los ficheros compilados (DCU, DCP, EXE, BPL) del directorio.





Eliminamos el package RESTAS.BPL, de la lista de "Runtime Packages" con lo que estamos diciendo que "no es un package de Runtime" o no le estamos diciendo expresamente que lo sea:



Si ahora compilamos nuestro ejecutable, como en ningun sitio le hemos indicado que ese RESTAS.BPL es un "Runtime Package", lo que delphi hace (ya que encuentra los fuentes) es añadirlas al ejecutable.
Para comprobarlo vemos que en disco sólo se genera el fichero del ejecutable y si lo revisamos con alguna herramienta para ver recursos, se puede ver que el formulario que estaba definido dentro del package (UMain.pas con la clase TFormMain) se ha añadido al ejecutable:



Se ha añadido al EXE porque en nungun sitio se le ha especificado que los elementos pertenecientes a ese package deben ser tratados como tales.

Volvemos a borrar TODOS los ficheros compilados y probamos la segunda opción; Añadir a la lista de "packagesa en runtime" nuestro package "RESTAS.BPL".



Al intentar compilar ahora el ejecutable, vemos que ahora no añade esos elementos al EXE, sino que COMPILA primero el package RESTA.BPL (sin haberselo dicho explícitamente -lo saca de esa lista-) y posteriormente compila el EXE. Si miramos ahora el EXE vemos que no incluye los formularios que están en el package:



Determina qué packages en runtime va a utilizar tu aplicación, por lo tanto obligas a que esos packages estén generados y disponibles (DCP) en el momento de compilar tu EXE. En ese momento comprueba que en esos packages esta lo que tú necesitas (Units añadidas al uses) y compila tu EXE.
Lo que no está en esos packages, al encontrarlo se incluye en tu EXE.

[[Caral]]

Hola
Muy interesante tema.
Hacia falta algo asi, ademas muy bien explicado.
Gracias por el aporte.
Saludos

[urixiv]

Gran explicación sobre Bpls, Dlls, y exes!!!
Siempre va bien poderlo leer todo del tirón para entender bien como funciona!!

GRACIAS

[roman]

Empezado por Neftali

Con ese Edit estás obligando (o indicando) a que ese package realmente sea un package en Runtime; No se van añadir al programa principal.

Algo así tenía idea. Pero, entonces, si de dicha lista quitamos vcl, en teoría, podríamos generar un ejecutable en el que sólo nuestros paquetes personales sean dinámicos, evitando así tener que redistribuir la vcl.

Lo curioso es que si quitas todos los paquetes de la lista, la opción "Build with runtime packages" se desmarca sola. No he probado si agregamos un paquete personal y quitamos la vcl si realmente sucede lo que digo.

// Saludos

[rgstuamigo]

Pues yo estaba casi nulo en éstos asuntos de "carga dinámica y estática de packages y dll", pero ahora con la super explicacion de Neftali pues ya le voy entendiendo a la cosa..
Muchas gracias Neftali por dar tanto de tu conocimiento..
Saludos...

[Casimiro Notevi]

Yo sólo conocía la parte de los bpl porque hace años nos encontramos que nuestro .exe era tan grande que los win98 y winMe no los podía ejecutar, así que lo compilamos con las bpl aparte y con el tamaño resultante del .exe ya sí que pudimos ejecutarlo en esos sistemas.
Sin embargo con winNT y 2000 sí que funcionaban con "todo dentro".

[Neftali [Germán.Estévez]]

Empezado por roman

Pero, entonces, si de dicha lista quitamos vcl, en teoría, podríamos generar un ejecutable en el que sólo nuestros paquetes personales sean dinámicos, evitando así tener que redistribuir la vcl.

En teoría sí, si eliminamos todos los DCPs y BPL's y tenemos disponible el código fuente, debería añadirlos.

Empezado por roman

Lo curioso es que si quitas todos los paquetes de la lista, la opción "Build with runtime packages" se desmarca sola. No he probado si agregamos un paquete personal y quitamos la vcl si realmente sucede lo que digo.

Si dejas un sólo paquete lo mantiene, es al dejarlo vacío que lo desactiva.

[Neftali [Germán.Estévez]]

Lo prometido es deuda, así que he completado la entrada en mi blog, y allí mismo podéis encontrar el código de los ejemplos que os adjunto a este mensaje.

[ContraVeneno]

Empezado por Neftali

...Al intentar compilar ahora el ejecutable, vemos que ahora no añade esos elementos al EXE, sino que COMPILA primero el package RESTA.BPL (sin haberselo dicho explícitamente -lo saca de esa lista-) y posteriormente compila el EXE....

Muy buen tema, Gracias Neftalí.

Solo aclarar, que se compilaría pimero el BPL, solo si este tiene seleccionada la opción de "reconstruir cuando sea necesario" ("Rebuild as needed"). Si se tiene la opción de "reconstrucción explícita" ("Explicit rebuild") el BPL no tendría porque compilarse cada vez que se compile el proyecto donde se le requiera.

Saludos.

[Neftali [Germán.Estévez]]

Empezado por ContraVeneno

Solo aclarar, que se compilaría pimero el BPL, solo si este tiene seleccionada la opción de "reconstruir cuando sea necesario" ("Rebuild as needed"). Si se tiene la opción de "reconstrucción explícita" ("Explicit rebuild") el BPL no tendría porque compilarse cada vez que se compile el proyecto donde se le requiera.

Correctísima aclaración ContraVeneno.
En mi caso estaba dando por supuesto que el package no existía, de ahí que asumía siempre se generara.

[ecfisa]

Neftalí:

Muy esclarecedor el post.

Gracias por compartirlo.

Saludos.

[[BlueSteel]]

Que interesante esto.. me apundo para tenerlo a manos despues


Salu2

[ElDuc]

Hola, en realidad no sé si alguien verá este post, ya que el hilo se creó hace 9 años.

Bueno por si lo veis, comentaros que ahora yo estoy con este lio de los paquetes y que me estoy volviendo loco, trabajo con D2010, por si sirve de algo.

La explicación de Neftali está meridianamente clara y creo que la comprendo bien, pero cuando lo hago me sales esto:
" ..\Prueba1.exe no es una aplicación Win32 válida"

Alguien me puede ayudar?, muchas gracias.

[ElDuc]

Perdonad, he pensado que si ponía toda la información sería más fácil que alguien me ayudara.

Paso 1:
Realizo un proyecto normal, Aquí pongo el project manager para que podáis ver el contenido del proyecto:


El código de las 2 unidades es el siguiente:

Código Delphi [-]
Unit uForm1;

Interface

Uses
    uForm2,
    Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
    Dialogs, StdCtrls;

Type
    TForm1= Class(TForm)
        Button1: TButton;
    procedure Button1Click(Sender: TObject);
    Private
        { Private declarations }
    Public
        { Public declarations }
    End;

Var
    Form1: TForm1;

Implementation

{$R *.dfm}

Var
    Form2:TForm2;

procedure TForm1.Button1Click(Sender: TObject);
begin
Form2:=TForm2.Create(Application);
Form2.ShowModal;
Form2.Free;
end;

End.

Código Delphi [-]
unit uForm2;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TForm2 = class(TForm)
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form2: TForm2;

implementation

{$R *.dfm}

end.

Selecciono en las opciones para que el Form2 no se cree automáticamente


Compilo y ejecuto y todo va bien, me aparece


Y cuando pulso el botón se abre el formulario 2


Guardo y cierro todo y creo el paquete


Compilo (build) y lo guardo, ahora vuelvo a abrir el proyecto original y cambio para que utilice el paquete


Guardo, compilo y ejecuto y me sale esto


No sé como solucionarlo, Help me!

[Neftali [Germán.Estévez]]

¿Puedes meter todos los fuentes en un fichero ZIP y subirlo para que lo probemos?
A ver si hay algo raro....

[ElDuc]

Hola Neftali,

Perdona pero no sé cómo se suben los archivos, ¿puedes indicarme cómo se hace?

Gracias y disculpa las molestias.

[ContraVeneno]

puedes poner el archivo en dropbox, skydrive, googledrive, rapidshare o cualquier otro servicio de archivos, y aquí nos compartes el enlace para poder descargarlo.

[ElDuc]

Hola otra vez, he tardado porque me he tenido que registrar y ver como funciona.

Aquí está el enlace
https://www.dropbox.com/s/2vg5au2w8xmave9/Fonts.ZIP

Gracias por tu ayuda.