'enchaînez' une série de fonctions dans ActionScript 3

Question

J'appelle une fonction et j'ajoute un écouteur lorsque la fonction renvoie des données. lorsque les données sont renvoyées, je dois appeler une autre fonction, etc.

.

Existe-t-il un moyen simple d’enchaîner ces fonctions pour que la première se déclenche - attend l’auditeur, puis déclenche la seconde pour créer un écouteur et ainsi de suite jusqu’à ce que le dernier appelle une fonction distincte définie au début. Je suppose que je travaillerais sur les mêmes lignes que les scripts de chargement en bloc.

J'envisage que le code fonctionne à peu près comme ceci:

var dataLoader:DataLoader = new DataLoader(onAllComplete, onError);

dataLoader.add(getData1, {args1, args2}, listnerType.DATA_LOADED);
dataLoader.add(getData2, {args3, args4}, listnerType.DATA_LOADED);
dataLoader.add(getData3, {args5, args6}, listnerType.DATA_LOADED);

dataLoader.start();

private function onAllComplete(e:Array):void {
  //where e contains an array of all the event results
}
private function onError(e:Event):void {
  //will fire if there are any errors along the way
}

Merci, Josh

Answer 1

Je voudrais juste faire quelque chose de simple, tel que: (également, c'est un pseudocode de tri, vous aurez besoin des événements d'erreur corrects)

var numLoaded:int = 0;
var numError:int = 0;
var loadingIndex:int = 0;

var itemsToLoad:Array = ['img1.jpg', 'img2.jpg', 'img3.jpg'];

public function startLoading():void{
     loader.load(itemsToLoad[loadingIndex];
     loader.addEventListener(Event.COMPLETE, completeHandler);
}

public function completeHandler(event:Event):void{
     loadingIndex++;
     numLoaded++;
     if(numLoaded + numError >= itemsToLoad.length){
          onAllItemsComplete();
     }else{
          loader.load(itemsToLoad[loadingIndex];
     }
}

public function errorHandler(event:Event):void{
     loadingIndex++;
     numError++;
     if(numLoaded + numError >= itemsToLoad.length){
          onAllItemsComplete();
     }else{
        loader.load(itemsToLoad[loadingIndex]; 
     }
}

Answer 2

Été là, fait ça. Voici le code AS3:

package com.vpg.rns.util {

    public class AsynchIterator {
        private var iteratorPosition:int;
        private var iterableObjects:Array;
        private var onApply:Function;
        private var onComplete:Function;
        private var done:Boolean;

        public function get position() { return iteratorPosition; }

        public function get isDone() { return done; }

        public function get size() { return iterableObjects.length; }

        /** Create an iterator that will call the given function repeatCall once for each object in iterableObjects, before finally calling completeCall once at the end.
         * The calls will be made asynchronously, with event handlers used to stitch it all together.
         *
         * @param iterableObjects ....... Every object in this array will be passed as the first argument to repeatCall, in order.
         * @param repeatCall ............ This function will be called once for each object in iterableObjects. Its signature is repeatCall(Object, Function).
         * @param completeCall .......... Called once after every item in the array has been processed.
         *
         *
         */
        public function AsynchIterator(iterableObjects:Array, repeatCall:Function, completeCall:Function) {
            this.iteratorPosition = 0; 
            this.iterableObjects = iterableObjects;
            this.onApply = repeatCall;
            this.onComplete = completeCall;
            this.done = false;
        }

        public function iterate():void {
            doNext();
        }

        private function doNext() {
            if (isDone) {
                // Do nothing - already called onComplete. 
            }
            else if (position == size) { 
                done = true;
                onComplete();
            }
            else {
                var obj:Object = iterableObjects[iteratorPosition++];
                onApply(obj, doNext);
            }
        }

    }

}

Évidemment, vous voudrez ajouter une fonction de gestion des erreurs, garder trace de ceux qui ont échoué et réussi, ajouter des options pour échec rapide par rapport à tout-vous-pouvez, etc.

• Paul

Answer 3

Je comprends peut-être mal vos intentions, mais d'après ce que vous avez décrit, vous pouvez les enchaîner lorsque les gestionnaires sont appelés ... comme: Voulez-vous faire quelque chose comme cela, mais avec une syntaxe plus condensée?

private function onComplete1(event:Event):void
{
    dataLoader.removeEventListener("onComplete", onComplete1);
    dataLoader.addEventListener("onComplete", onComplete2);

    ... // process event

    dataLoader.load(); // I don't remember the exact calls...
}

private function onComplete2(event:Event)void
{
    dataLoader.removeEventListener("onComplete", onComplete1);
    dataLoader.addEventListener("onComplete", onComplete2);

    ... // process event

    dataLoader.load(); // I don't remember the exact calls...
}

Answer 4

Cette interface me semble bonne. L'implémentation dépend de la manière dont les fonctions renvoient leurs données. AS3 ne supporte pas les threads, vous devez donc écrire vos fonctions getData () pour une exécution asynchrone. Si vous chargez des données depuis un site distant ou quelque chose de simple, utilisez simplement les fonctions de chargement intégrées, utilisez getBytesLoaded () pour indiquer quand elles ont terminé et appelez votre rappel OnComplete lorsque tout le monde est chargé.

Si vous effectuez un calcul très long, vous devrez le diviser. Quelque chose comme:

class Computation {
    function Step() {/* ... */}
    function IsFinished() {/* ... */}
    function GetResult() {/* ... */}
}

Sous-classez quelque chose comme ça pour chaque type de calcul que vous devez faire, puis passez les instances dans votre chargeur de données. Demandez-leur Step () une fois par image et appelez le rappel OnComplete quand ils ont tous terminé.

Answer 5

splinklibrary contient des classes qui gèrent assez bien les opérations asynchrones enchaînées.