Llamadas dinámicas en ActionScript 3.0

Estoy haciendo una plataforma en flash (AS3) para crear mini-sites mas fácil para la empresa con la que estoy ahora, debido a esto he estado explorando patrones y otras cosas y he revisado las fuentes del Symfony y observé algo interesante:

Para poder hacer llamado de métodos en las acciones desde un template se usa

"link_to ('modulo/accion' );"

Esto se procesa en el controlador y llama dinámicamente a la clase y el método que se pone en el string de entrada en la función "link_to". Es uno de los pilares de este framework para hacer uso del patrón MVC, es totalmente práctico poder hacer algo como esto ya que permite realizar llamadas a métodos dinámicamente recibiendo el nombre desde archivos de configuración, bases de datos o cualquier otro tipo de entrada, incluso te permite hacer algo como:

var $metodo = $metodo_Configurado_En_El_Template;
if ( $error ) $metodo = "errorModulo";

call_method ( $metodo ); // Algo así es el nombre de la función en php que permite hacer este tipo de ejecuciones dinámicas.

Esto es el Core del asunto. Bueno pensando un rato y leyendo otro me pregunté si podría hacer algo similar en AS3 y luego de buscar un poco hice una prueba y esto es lo que encontré: (adelanto, SI SE PUEDE).

Para cargar una clase dinámicamente y crear una instancia hacemos:

var clase : Class = getDefinitionByName ( "myclase" );
var instancia : Object = new clase ();

Hasta aca no hay nada nuevo, es lo mismo que se usa para usar un movieclip con linkage desde las fuentes de código. Lo que descubrí es que en flash, los métodos y atributos públicos son almacenados en forma de un array asosiativo en una instancia de una clase, es decir, cuando yo creo "instancia", luego puedo llamar a sus métodos como si "instancia" fuera un array asosiativo y cada método o atributo es un dato dentro del array. Para acceder al dato el nombre que le demos al atributo o método es el "key" usado en el array para extraer su valor. Teniendo esto podemos hacer algo como esto:

prueba.as:
------------
package
{
public class Prueba
{
public function debug () : void
{
trace ( "es una prueba" );
}

public function release () : void
{
trace ( "versión final" );
}
}
}


main.as:
----------
package
{
public class Main
{
public function Main ()
{
var obj : Prueba = new Prueba (); // Instancia de la clase

// Trata al objeto "obj" como un array asosiativo y accedemos al campo con key="debug"
// Esto nos retorna un método que luego invocamos usando "()".
obj [ "debug" ] ();

// Podemos hacer algo como:
var metodo : String = "debug";

// ... código de lógica que hace cambiar la variable
// finalmente decidimos que método usar y lo llamamos:
obj [ metodo ] ();


// Esta lógica puede ser dada por una función tipo "link_to" usada en Symfony:
// link_to ( "modulo/metodo" );
var tmp : String = link_to.getRuta (); //retorna algo como "modulo/metodo"
var path : Array = tmp.split ( "/" ); // retorna un array asi: [0] => modulo, [1] => metodo

// el primer array retorna el nombre del método "metodo" y
// el segudo retorna su cuerpo y lo ejecuta, de esta manera tenemos un controlador y
// soporte para llamar multiples métodos internos a las clases dinámicamente.
obj [ path [ 1 ] ] ();
}
}
}


Bueno esto es todo lo que descubrí en mi búsqueda, espero sea de utilidad, cualquier duda dejarla y la contestaré. Por ahora yo usaré esto para terminar de implementar mi plataforma con llamadas dinámicas para hacerla flexible :P.