Ordine di gestione evento Adobe Flex/Actionscript

Question

Nel modo più semplice possibile, sto cercando di scoprire se gli eventi sono garantiti per essere gestiti nell'ordine in cui vengono inviati. Diciamo che ho il seguente codice semplice:

private function handler1(e:Event):void { .. processing ..} 
private function handler2(e:Event):void { .. processing ..} 
private function handler3(e:Event):void { .. processing ..} 

<SomeComponent myEvent1="handler1(event)" myEvent2="handler2(event)" myEvent3="handler3(event)" ... /> 

Se da qualche parte nella mia applicazione (sia all'interno del componente stesso o in un altro luogo con il componente istanziato), se la spedizione quegli eventi nell'ordine di 1, 2 , 3, come:

dispatchEvent(new Event('myEvent1')); 
dispatchEvent(new Event('myEvent2')); 
dispatchEvent(new Event('myEvent3')); 

sono quelli gestori garantiti a fuoco nello stesso ordine (vale a dire, handler1, handler2, handler3) ...? Qualunque cosa io ricerchi su Internet (leggi: Google) per quanto riguarda "l'ordine di elaborazione degli eventi di Adobe" o qualcosa di simile si riferisce solo al ciclo di vita dell'evento. Non riesco a trovare nulla su questa sfumatura specifica però. Qualsiasi aiuto è molto apprezzato.

--Ian

Answer 1

Se due eventi vengono inviati uno dopo l'altro come indicato nel codice, il secondo evento verrà inviato solo dopo l'esecuzione di tutti i gestori del primo evento e viene restituito il metodo dispatchEvent.

private function handler_1(e:Event):void {} 
private function handler_2(e:Event):void {} 

a.addEventListener(Event.TYPE_1, handler_1); 
a.addEventListener(Event.TYPE_2, handler_2); 

//Different events: 
//handler_1 will be called before handler_2 
a.dispatchEvent(new Event(Event.TYPE_1)); 
a.dispatchEvent(new Event(Event.TYPE_2)); 

Ma se hai registrato due listener registrati con stessa priorità per un evento, vengono elaborati nell'ordine in cui sono stati aggiunti.

private function handler_1(e:Event):void {} 
private function handler_2(e:Event):void {} 

a.addEventListener(Event.TYPE_1, handler_1); 
a.addEventListener(Event.TYPE_1, handler_2); 

/* 
    Same event, same priority: 
    Called based on the order in which they were added; 
    Hence handler_1 is called first. 
*/ 
a.dispatchEvent(new Event(Event.TYPE_1)); 

È possibile utilizzare il parametro priority del metodo addEventListener di far rispettare l'ordine:

a.addEventListener(Event.TYPE_1, handler_1, false, 0); 
a.addEventListener(Event.TYPE_1, handler_2, false, 1);//higher priority 

/* 
    handler_2 will be invoked before handler_1 
*/ 
a.dispatchEvent(new Event(Event.TYPE_1)); 

Answer 2

fanno di solito, ma non c'è alcuna garanzia, quindi non si dovrebbe presumere che lo faranno.

Answer 3

Se Dio ci aveva lo scopo di conoscere l'ordine in cui si verificheranno gli eventi, lui non avrebbe dato noi callLater()

;) La risposta di

Answer 4

Idem Robert Bak. Se è assolutamente necessario eseguire questo lavoro per qualsiasi motivo, è possibile taggare gli eventi con un numero che aumenta di un'unità ogni volta, chiedere agli ascoltatori di archiviarli in una coda centrale di qualche tipo, quindi ordinarli in base a l'indice che hai assegnato. Probabilmente più lavoro di quanto valga la pena.

Answer 5

Generalmente il ciclo di eventi inizia quando si verifica un invio di eventi, passa a quello principale e quindi aumenta la gerarchia dell'interfaccia utente tramite altri genitori da cui si passa indietro ai suoi figli. Di seguito è riportato un diagramma che illustra il ciclo di vita dell'evento in Flex:

Eventi passare attraverso diverse fasi, ma alcuni eventi possono essere limitati da certe fasi. Quando si crea un nuovo evento, è possibile evitare che l'evento si ribalti durante la fase di bubbling. Per maggiori dettagli leggi Essential ActionScript 3.0 di Colin Moock.

Gli eventi non vengono attivati ​​o elaborati in alcuna sequenza. Si allontanano quando l'evento viene licenziato. In Flex, gli eventi sono asincroni.