‚Kette‘ eine Reihe von Funktionen zusammen in Actionscript 3

Question

Ich rufe eine Funktion und das Hinzufügen eines Zuhörers für, wenn die Funktion einige Daten zurückgibt. wenn die Daten zurückgegeben ich brauche eine andere Funktion aufzurufen, und so weiter.

Gibt es eine einfache Art und Weise zu ‚Kette‘ so diese Funktionen zusammen, dass die ersten Brände - wartet auf die Zuhörer feuert dann die zweite einen Listener für das Erstellen und so weiter, bis die letzte eine separate Funktion aufruft, die definiert ist, am Anfang. Es würde ich nehme an Arbeit auf der gleichen Linie wie die Bulk-Loader-Skripten.

Ich bin vorsehen, den Code so etwas wie dies funktioniert:

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
}

Danke, Josh

Answer 1

Ich würde nur tun, etwas Einfaches wie: (auch dies ist eine Art Pseudo-Code, müssen Sie die richtigen Fehlerereignisse und solche Sachen)

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

Been there, done that. Hier ist der AS3-Code:

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

    }

}

Natürlich, werden Sie einen Fehler-Handler-Funktion hinzuzufügen, zu verfolgen, welche ausgefallen und es gelang ihm, Optionen hinzufügen, für schnell scheitern im Vergleich do-all-you-can, etc.

• Paul

Answer 3

Ich könnte Ihre Absichten wird Missverständnis, aber von dem, was Sie beschrieben, können Sie verketten sie, wenn die Handler aufgerufen werden ... wie: Haben Sie so etwas wie dies tun wollen, aber mit mehr kondensierten Syntax

?

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

Das Interface sieht gut für mich. Die Umsetzung hängt davon ab, wie die Funktionen ihre Daten zurück. AS3 nicht Threads unterstützen, so dass Sie Ihre getData () Funktionen schreiben asynchron auszuführen. Wenn Sie Daten von einem entfernten Standort sind geladen oder etwas so einfach ist, verwenden Sie einfach die integrierten in Laderfunktionen verwenden getBytesLoaded () zu sagen, wenn sie fertig sind, und rufen Sie Ihren OnComplete Rückruf bei jeder geladen wird.

Wenn Sie nur eine wirklich lange Berechnung tun, Sie gehen, um es aufzubrechen. So etwas wie:

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

Unterklasse so etwas für jede Art von Berechnung Sie tun müssen, dann Instanzen in Ihre Daten-Loader übergeben. Haben sie Schritt () einmal pro Rahmen, und rufen Sie die OnComplete Rückruf, wenn sie alle fertig sind.

Answer 5

splinklibrary enthält Klassen, die ganz gut mit verketteten asynchronen Operationen beschäftigen.