La ejecución de eventos en forma paralela o secuencial usando solamente las características de Flex 3 es imposible debido a la ejecución en forma asíncrona. Aquí es donde podemos usar una de las características de las extensiones para Cairngorm desarrolladas por UniversalMind que permite crear cadenas de eventos, pudiendo invocar a dichos eventos de forma secuencial o de forma paralela. Estas cadenas de eventos son creadas mediante la clase EventGenerator
Para poder encadenar eventos usando el framework Cairngorm, los eventos deben extender de la clase UMEvent, una clase de eventos deberá tener una estructura como la que se presenta a continuación.
import com.universalmind.cairngorm.events.UMEvent;
import mx.rpc.IResponder;
public class Event1 extends UMEvent
{
static public var TYPE_EVENT:String = "typeEvent";
private var parameter:String;
public function Event1t(type:String, parameter:String, handlers:IResponder=null, bubbles:Boolean=true, cancelable:Boolean=false)
{
this.parameter=parameter;
super(type);
}
}
Además los comandos deben extender de la clase Command dentro del paquete de UniversalMind com.universalmind.cairngorm.commands. Estos comandos deben sobreescribir los métodos execute, result y fault, aunque éste último puede ser obviado si se utiliza otra característica de la extensiones para Cairngorm que permite centralizar el manejo de errores mediante la clase FaultCommand, una clase de comandos debe tener una estructura como la que se presenta a continuación.
import com.adobe.cairngorm.control.CairngormEvent;
import com.universalmind.cairngorm.commands.Command;
import flash.events.IEventDispatcher;
import Event1;
public class Command1 extends Command
{
private var event1:Event1;
override public function execute(event:CairngormEvent):void
{
super.execute(event);
event1=event as Event1;
var delegate:Delegate=new Delegate(this);
delegate.ExecuteEvent(event1.parameter);
}
override public function result(info:Object):void
{
//resultado de ejecucion de Event1
notifyCaller(info);
}
override public function fault(info:Object):void
{
notifyCaller(info);
}
}
Para notificar acerca de la ejecución de los comandos se debe llamar al método
notifyCaller.
Luego usando la clase
EventGenerator se puede crear cadenas de eventos que pueden ser ejecutadas en forma paralela o secuencial. El código a continuación permite despachar eventos en forma paralela. El constructor de esta clase recibe como parámetros:
- Un arreglo con los eventos a ejecutar
- Los handlers opcionales para el resultado de la ejecución de los comandos
- Un entero que representa el como se manejarán los errores
- El tipo de ejecución de los eventos, puede ser, EventGenerator.TRIGGER_PARALLEL o EventGenerator.TRIGGER_SEQUENCE
var paralellLocaleEvents:Array=[new Event1(Event1.TYPE_EVENT, "parameter"), new Event2(Event2.TYPE_EVENT), new Event3(Event3(Event3.TYPE_EVENT)];
var eventLocaleGenerator:EventGenerator=new EventGenerator(paralellLocaleEvents, null, 0, EventGenerator.TRIGGER_PARALLEL);
eventLocaleGenerator.dispatch();
También pueden ser encadenados eventos en forma paralela y secuencial en conjunto, por ejemplo el ejemplo a continuación ejecutará en paralelo Event1 con los eventos Event2 y Event3 que se ejecutarán ambos en secuencia.
var sequenceEvents:Array=[new Event2(Event2.TYPE_Event), new Event3(Event3.TYPE_EVENT)];
var sequenceEventGenerator:EventGenerator=new EventGenerator(sequenceEvents, null, 0, EventGenerator.TRIGGER_SEQUENCE);
var parallelEvents:Array=[new Event1(Event1.TYPE_EVENT, "parameter"), sequenceEventGenerator];
var parallelEventGenerator:EventGenerator=new EventGenerator(parallelEvents, null, 0, EventGenerator.TRIGGER_PARALLEL);
parallelEventGenerator.dispatch();
