Acceso a BPLs

[ezindetgeio]

No sé si he explicado bien mi duda.

Quizás es que sigo sin entender bien para qué valen los famosos BPLs.

En los ejemplos que siempre leo un BPL siempre lleva consigo especializaciones de objetos típicos como Forms o así.

Pero... cuando la clase o clases que van en el BPL son mías y son de lógica de negocio como la que explico arriba...

Una vez cargado el BPL en ejecución, ¿cómo hago para crear una instancia de esa clase y que el compilador me reconozca que es de ese tipo y que sepa de los símbolos de la misma (sus métodos, etc.)?

No encuentro manera.

En cambio, si hago uno uses UClasePrueba y añado el .bpl como componente a lo bestia en la opción del proyecto, ya sí que me lo ve.

La cuestión es, ¿cómo hacer esto programáticamente en el código?

¿No es igual hacer un LoadPackage de un paquete que registra sus clases a poner la opción del .bpl en el proyecto y poner el uses?

¿Qué más me falta?

Leo libros sobre Deplhi y tutoriales y sólo veo que siempre que se usa LoadPackage es para recoger una clase que especializa a una que ya se tiene en la aplicación (un formulario específico por ejemplo) y que por lo tanto, con hacer una instancia sobre un tipo base que conozco y al cuál hace override a sus métodos le vale.

¿Es ese el alcance del uso de los .bpl?

No puede ser así puesto que evidentemente hemos quedado que el .exe se lleva sólo el .bpl y se lleva toda la compilación y linkado de símbolos y demás del paquete.

¿Dónde puedo leer más sobre RTTI?

[ezindetgeio]

Más del mismo pesado...

Si sigo algunas indicaciones de RTTI hay una manera que sí em funciona, pero, ¿es la única?

Si hago que la clase sea así:

Código Delphi [-]
unit  UClasePrueba;
 
 interface
 
 uses
     Windows, Messages,  SysUtils, Classes;
 
 type
     TClasePrueba =  class(TPersistent)
          private
             sNombre:  String;
             sEdad:  Integer;
             //procedure  CreatePrueba(nombre: String; edad: Integer);
             function  GetNombre : String;
             procedure  SetNombre(const nombre: String);
             function GetEdad  : Integer;
             procedure  SetEdad(const edad: Integer);
          public
 
          published
             property Nombre:  String read GetNombre write SetNombre;
             property Edad:  Integer read GetEdad write SetEdad;
      end;
 
 implementation
 
 {procedure  TClasePrueba.CreatePrueba(nombre: String; edad:  Integer);
 begin
     sNombre :=  nombre;
     sEdad :=  edad;
 end;  }
 
 procedure  TClasePrueba.SetNombre(const nombre: String);
 begin
     sNombre :=  nombre;
 end;
 
 procedure  TClasePrueba.SetEdad(const edad: Integer);
 begin
     sEdad :=  edad;
 end;
 
 function  TClasePrueba.GetNombre() : String;
 begin
     result :=  sNombre;
 end;
 
 function  TClasePrueba.GetEdad() : Integer;
 begin
     result :=  sEdad;
 end;
 
 initialization
 
      RegisterClass(TClasePrueba);
 
 finalization
 
      UnRegisterClass(TClasePrueba);
 
 end.

Y lo llamo como:

Código Delphi [-]
unit  Paquetes;
 
 interface
 
 uses
   Windows, Messages, SysUtils,  Classes, Graphics, Controls, Forms, Dialogs,
   StdCtrls,  TypInfo;
 
 type
   TForm1 =  class(TForm)
     Button1:  TButton;
     procedure Button1Click(Sender:  TObject);
    private
     { Private declarations  }
    public
     { Public declarations  }
   end;
 
 var
   Form1:  TForm1;
 
 implementation
 
 {$R  *.DFM}
 
 procedure  TForm1.Button1Click(Sender: TObject);
 var
     Paquete:  HModule;
     PruebaClass:  TPersistentClass;
     Prueba:  TPersistent;
     nombre:  String;
 begin
     Paquete :=  LoadPackage('PaquetePrueba.bpl');
 
     if (Paquete <> 0)  then
      begin
         Showmessage('Paquete  Cargado');
 
         PruebaClass :=  TPersistentClass(GetClass('TClasePrueba'));
 
         if (Assigned (PruebaClass))  then
          begin
             Showmessage('Clase  cargada');
 
             Prueba :=  PruebaClass.Create;
              try
                 SetPropValue (Prueba,  'Nombre', 'Benjamin');
                 nombre :=  getPropValue(Prueba, 'Nombre');
 
                  ShowMessage(nombre);
              finally
                 Prueba.Free;
              end;
 
          end;
 
          UnloadPackage(Paquete);
 end;
 end;
 
 end.

¿Y si quién diseño los .bpl no utilizó este metodología?

¿Es la única posible? Seguimos leyendo.

Muchas gracias.

Saludos.

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

Empezado por ezindetgeio

¿Y si quién diseño los .bpl no utilizó este metodología?
¿Es la única posible?

Bueno, esa sería la más correcta (utilizando propiedades Public/published y procedures/funciones de acceso private) .
Te lo quería comentar, porque en tu ejemplo no estabas utilizando propiedades, pero tal y como estaba me servía para mostrarte la forma de acceder a procedimientos y funciones. Para acceder a las propiedades es mucho más fácil tal y como has hecho tú, ya que delphi provee de la unit TypInfo que posee mátodos para ello (revísala si todavía no lo has hecho).

El único inconveniente que te puedes encontrar es que, si quien diseñó los BPL's utilizó propiedades/métodos Public en lugar de Published (que en muchos casos son suficientes); En ese caso no podrás acceder a ellos, ya que para RTTI necesitas obligatoriamente que sean Published.

[ezindetgeio]

Muchas gracias Neftali!

Te debo más de una.

Ahora mismo me miro la opción sin properties, a ver que tal me va.

Saludos.

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

Empezado por ezindetgeio

Ahora mismo me miro la opción sin properties, a ver que tal me va.

Que conste que no son excluyentes; Normalmente los objetos tienen propiedades y métodos; A cada cosa lo suyo y estos son los dos métodos que debes utilizar.
En el caso de Nombre y Edad yo los veo como propiedades.

[ezindetgeio]

No si ya. la opción d elos properties a mí me gusta. Pero no me hago yo todos los BPLs, ahí está el problema.

Así que más me vale aprender otras opciones

Muchas gracias de nuevo.

¡Un saludo!