Ordre de traitement des événements Adobe Flex/Actionscript

Question

Aussi simplement que possible, j'essaie de savoir si les événements sont gérés dans l'ordre de leur expédition. Disons que je le suit, le code simple:

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)" ... /> 

Si quelque part dans ma demande (soit à l'intérieur du composant lui-même ou un autre endroit avec le composant instancié), si j'envoie ces événements dans l'ordre de 1, 2 , 3, comme:

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

sont ceux des gestionnaires garanti au feu dans le même ordre (c.-à-handler1, handler2, handler3) ...? Tout ce que je recherche sur Internet (lire: Google) pour ce qui concerne "ordre de traitement des événements adobe" ou quelque chose de similaire se réfère simplement au cycle de vie de l'événement. Cependant, je ne trouve rien sur cette nuiance spécifique. Toute aide est grandement appréciée.

--Ian

Answer 1

Si deux événements sont distribués l'un après l'autre comme indiqué dans votre code, le second événement sera envoyé uniquement après l'exécution de tous les gestionnaires du premier événement et la méthode dispatchEvent est renvoyée.

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)); 

Mais si vous avez enregistré deux écouteurs enregistrés avec la même priorité pour un événement, ils sont traités dans l'ordre dans lequel ils ont été ajoutés.

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)); 

Vous pouvez utiliser le paramètre priority de la méthode addEventListener pour faire respecter l'ordre:

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

Ils le font habituellement, mais il n'y a aucune garantie, vous ne devriez pas supposer qu'ils le feront.

Answer 3

Si Dieu avait voulu que nous de connaître l'ordre dans lequel les événements se produiront, il n'aurait pas donné nous callLater()

;)

Answer 4

réponse de Ditto Robert Bak. Si vous avez absolument besoin de faire ce travail pour quelque raison que ce soit, vous pouvez étiqueter les événements avec un nombre qui augmente d'une unité chaque fois, demandez à vos auditeurs de simplement les stocker dans une file d'attente centrale, puis les trier selon l'index que vous avez attribué. Probablement plus de travail que cela en vaut la peine.

Answer 5

Généralement, le cycle d'événement commence lorsqu'un événement se produit, passe à son parent, puis monte dans la hiérarchie de l'interface utilisateur par l'intermédiaire d'autres parents d'où il descend à travers ses enfants. Voici un schéma qui illustre le cycle de vie de l'événement dans Flex:

événements passent par différentes phases, mais certains événements peuvent être limités à certaines phases. Lors de la création d'un nouvel événement, vous pouvez empêcher l'événement de bouillonner pendant la phase de formation de bulles. Pour plus de détails, lisez Essential ActionScript 3.0 par Colin Moock.

Les événements ne sont déclenchés ou traités dans aucune séquence. Ils dépendent du moment où l'événement est déclenché. Dans Flex, les événements sont asynchrones.