Pregunta complicada...
 

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.

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

Saludos!

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=/...ctices/SAP-VCL (si te estudias este articulo vas a entender mejor) que lo he mejorado un poquito

La implementacion es mas o menos:

Código Delphi [-]
 
 //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;

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:

Código Delphi [-]
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.

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)

Código Delphi [-]
  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.

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:

Código Delphi [-]
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

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

saludos....