Pregunta complicada...

[oliverinf]

Hola gente, como andadn??.

Les comento cual es mi duda para ver si alguien lo ha hecho.

Supongamos que tengo una variable "Nombre" de tipo String que contiene el nombre de una clase
como String.
Es decir, por ejemplo existe una clase que se llama Cliente y en la
variable "Nombre" tengo la cadena "Cliente"
(el nombre de la clase).

Existe la posibilidad de que dada la viariable con el nombre de una clase se cree un método
que retorne una instancia de dicha clase.

Espero se entienda mi duda.

Gracias.

PD. se que algunos lenguajes se puede hacer, pero en delphi aún no encontré la forma.

[delphi.com.ar]

Te recomiendo este hilo: http://www.clubdelphi.com/foros/archivo/viewtopic.php?t=7838

Saludos!

[mamcx]

Absolutamente que se puede. Y no, no es algo "magico" de los lenguajes, de hecho Delphi hace PRECISAMENTE eso cuando crea los formularios. El concepto es un patron (pattern) muy usado que se llama el Class Factory.

La explicacion a lo bestia es mas o menos asi:

Un "factory" es una clase de control que en base a un parametro determina la clase a construir"

PD. Si quieres una definicion mejor busca "Factory Pattern" o "Builder Pattern" en google....

Tengo un framework basado en http://www.devexpress.com/?section=/bestpractices/SAP-VCL (si te estudias este articulo vas a entender mejor) que lo he mejorado un poquito

La implementacion es mas o menos:


//1 Crea una clase base o una interface:
type
TfraBaseModulo = class(TfraBase)
.
.

//2 Crea las subclases o usa la interface
type
TfraInventarios = class(TfraBaseModulo)

type
TfraGrupos = class(TfraBaseModulo)

//3 Crea una clase "controladora" que se encarga de crea los objetos

//3.1 Metodo "a lo facil que no tengo tiempo" util para pocas subclases
// Desventaja: Cada vez que agreges una clase toca agregar el codigo en el creador de modulos

type
TAdministradorModulos = class (TInterfacedObject, IColeccion)
.
.
function TAdministradorModulos.RegistrarModulo(const Nombre: string);
var
oInfoModulo: TInfoModulo;
begin
if Modulo='Inventarios'
begin
result:=TfraInventarios.Create(...
end;
if Modulo='Grupos'
begin
result:=TfraGrupos.Create(...
end;

//3.2 Metodo "elegante que soy un genio" util para un numero indeterminado de clases
// Desventaja: una 2-3 horas mas de programacion y pruebas ;)

//3.2.1 Luego de la clase y sus metodos, agregar:
// Una tecnica avanzada de Delphi: Se puede pasar la CLASE y no la INSTANCIA para dejar para despues la creacion

initialization
AdministradorModulos.RegistrarModulo('Inventarios',TfraInventarios...);

//3.2.2 Hacer una funcion publica que carga el Administrador:
// MUY similar a como funciona Application (es que Delphi hace lo mismo ;) )
function AdministradorModulos: TAdministradorModulos;
begin
if FModuleInfoManager = nil then
begin
FModuleInfoManager := TAdministradorModulos.Create;
end;//if
Result := FModuleInfoManager;
end;

//3.2.3 Hacer una funcion de registro automatico de modulos o clases.. nota como usa la clase para crear los objetos. Se declara en la clase base

TfraModuloBaseClass = class of TfraBaseModulo;

procedure TAdministradorModulos.RegistrarModulo(const Nombre: string;
ClassModulo: TfraModuloBaseClass....)
oInfoModulo: TInfoModulo;
begin
// Create the module info and add it into the list
oInfoModulo := TInfoModulo.Create(Nombre,ClassModulo,ACategoria,ATipoInstancia);
Add(oInfoModulo);
end;

//3.2.4 Hacer una funcion dentro de la clase base o una ayudadora como hago en este caso, que crea la clase real
procedure TInfoModulo.CrearModulo(Clase:TfraModuloBaseClass;AOwner:TComponent);
begin
FModulo:=Clase.Create(AOwner);
FModulo.OnDestroy:=DoModuleDestroy;
FModulo.Align := alClient;
end;

[marto]

Wop!

Solo dos cosas, primero, montar un class factory es más sencillo que todo eso. Segundo, creo que que lo que el compañero quería era una función que instanciase "cualquier cosa". Ejemplo:


var
e: TEdit;
m: TMemo;
begin
e := Instanciar('TEdit');
m := Instanciar('TMemo');
end;


Y como bien se ha comentado, eso no se puede hacer en Delphi.

[mamcx]

Obvio, por eso puse la version facil y la completa.

Sin embargo, pensando que DELPHI HACE LO MISMO pues resulta que hay unas cuantas funciones bien interesantes:

VENTAJA: Tenemos listo un Factory con Delphi y no toca armar el codigo que puse arriba (al menos, para cosas no muy complejas)

FindClass ('TButton') //Para cualquier clase basada en TPersistent, busca por el tipo de clase
GetClass('TButton') //La busca por el nombre del componente, basado en TPersistent
FindComponent ('Un Nombre') //Lo busca por el nombre como MiControlEdit, debe estar DENTRO de otro control Forma1.FindControl....

RegisterClasses([TIcon, //Registra clases que no estan montadas aun en los forms o dentro de las clases de los forms y sus hijas, incluso LAS QUE UNO CREE EN BASE A TPersistent!

//Ejemplo:
procedure TForm1.BitBtn1Click(Sender: TObject);

begin
{ make sure the classes are registered so that GetClass will work -- }
{ Usually, this goes in the initialization section where it is only executed once }
RegisterClasses([TIcon, TBitmap, TJPEGImage, TMetafile]);
Edit1.Text := GraphicExtension(TGraphicClass(GetClass(Edit2.Text)));
end;



Con eso y el RTTI se hace mucha magia. Sin embargo la maxima flexibilidad es con un componente de Script Engine. Como el DWS o el TMS Script o el Pascal Script.

[roman]

Y como bien se ha comentado, eso no se puede hacer en Delphi.


Bueno, puede hacerse con GetClass pero la clase debe estar previemente registrada con RegisterClass que, a fin de cuentas viene a ser el registro en la fábrica.

Por otro lado la implementación que esboza mamcx no se me hace particularmente complicada o no veo forma de reducirla mucho.

De cualquier manera aprovecho este hilo para copiar la fábrica que menciona Federico del otro hilo:


unit fab;

interface

uses
Classes, Forms;

type
TFabrica = class
private
Lista : TStringList;
function GetClase(Nombre: String): TFormClass;

public
property Clases[Nombre: String]: TFormClass read GetClase; default;

constructor Create;
destructor Destroy; override;
procedure Registrar(Clase: TFormClass);
end;

var
Fabrica: TFabrica;

implementation

constructor TFabrica.Create;
begin
inherited;
Lista := TStringList.Create;
end;

destructor TFabrica.Destroy;
begin
Lista.Free;
inherited;
end;

procedure TFabrica.Registrar(Clase: TFormClass);
var
I : Integer;

begin
I := Lista.IndexOf(Clase.ClassName);

// Registrar si no lo está ya
if I = -1 then Lista.AddObject(Clase.ClassName, TObject(Clase));
end;

function TFabrica.GetClase(Nombre: String): TFormClass;
var
I : Integer;

begin
I := Lista.IndexOf(Nombre);
Assert(I <> -1, 'Clase no registrada');
Result := TFormClass(Lista.Objects[I]);
end;

initialization
Fabrica := TFabrica.Create;

finalization
Fabrica.Free;
end.


ya que en el hilo original han aparecido montones de líneas en blanco.

Está pensada para formularios pero se puede adaptar a otras clases base.

// Saludos

[oliverinf]

Gracias, por responder a mi pregunta. Voy a ponerme a investigar sobre el tema y despues les contaré como me fue.

saludos....