Design Patterns – Comunicazione tra classi in actionscript 3

Sarò breve e conciso (le ultime parole famose :))

Il problema che andrò ad affrontare è il seguente:
come faccio a comunicare ad una classe il risultato di una funzione, o pi√π generalmente dei “dati” elaborati in maniera asincrona da un’altra classe istanziata nella mia classe di partenza?

Se i dati fossero elaborati e restituiti in diretta non ci si porrebbe il problema, esempio ne sono le classi di largo consumo come Math e Date (es: var mioint:int = Math.round(9.99999)).

Ma se volessi delegare (termine usato non a caso, visto i trascorsi di as2 :)) a delle classi customizzate la mole di lavoro tipo delle routines di caricamento o qualcosa di simile?

Poniamo il caso di voler caricare una configurazione per la nostra applicazionesitogame… che risiede su un file cfg.xml.
Potremmo fare il tutto all’interno della document class cos√¨,

1. creiamo una private var _cfgxml:XML
2. nel costruttore andiamo a caricarci i dati con var myLoader:URLLoader = new URLLoader(new URLRequest(‘cfg.xml’));
3. appioppiamo al loader un gestore di evento Event.COMPLETE a cui associamo il parsing dei dati myLoader.addEventListener(Event.COMPLETE,cfgParse);
4. creiamo private function cfgParse(e:Evento) in cui istanziamo _cfgxml = new XML(e.target.data);

Ok, √® un’ipotesi plausibile, ma se questo nostro file richiedesse attenzioni particolari? o se semplicemente volessimo delegare ad altre classi le funzioni di parsing, di comunicazione con componenti, ecc ecc, solo per la soddisfazione di essere pi√π “puliti” nel codice…?

In actionscript 2 avremmo utilizzato Delegate passando come argomento la timeline (o l’istanza di classe) di riferimento. Ma in actionscript 3 “Delegate √® stat’ segheit” 😀

Si rende quindi necessario passare la timelineistanzadiclasse di riferimento come parametro per l’istanziazione della classe che elaborer√† i dati.

Esempio:

document class

private var _cfg:CFGManager;

public function Main(){
//costruttore
_cfg = new CFGManager(this);
_cfg.loadCFG();

}public function continuaMainClass(){}

classe richiamata dalla document class

private var _main:Main; //riferimento alla classe chiamante
public function CFGManager(m:Main){//costruttore
_main=m;//qui vado a memorizzare i riferimenti al main
}

public function loadCFG(){
//qui carico il mio xml di configurazione
//appioppo l'event listener per il caricamento
//e poi passo il tutto a parseCFG
}
private function parseCFG(e:Event){
//qui parso l'xml da e.target.data
//e poi faccio continuare l'esecuzione del main
_main.continuaMainClass();
}

Perfortuna non √® nulla di cos√¨ complesso 😀

Per ottimizzare il tutto per√≤ sar√† opportuno non ricevere in ingresso un parametro fortemente tipizzato, ad esempio la classe CFGManager accetta in input solo parametri di tipo “Main”…se si vuole “astrarre” il codice, in modo da renderlo riutilizzabile sar√† opportuno che accetti potenzialmente qualsiasi tipo di dato, da DisplayObject all’estremo “*”…ma poi sono gusti 😀

avevo detto che sarei stato breve, quindi alla prossima 😀