nombre arbitraire de gestionnaires Loader anonymes avec des données individuelles?

Question

J'ai un nombre arbitraire de fichiers que je dois charger dans une application AIR.

Je veux parcourir une série d'objets File et créer et lancer Loaders pour File.url de chacun.

Quand ils sont terminés (événement COMPLETED ou IOErrorEvent.IO_ERROR), je veux bourrer leurs données quelque part. Si elles échouent, je veux faire un rapport d'exception. Le meilleur moyen serait de créer des gestionnaires d'événements individuels pour chaque Launcher ayant les informations de fichier "codées en dur" dans celui-ci. À tout le moins, je pouvais utiliser la fonction elle-même comme un indice à un dictionnaire:

foo(fileToLoad : File) : void 
{ 
    var theCompletedHandler : Function = 
    { 
     var theFile : File = completedHandlerLookup[?????? this function ?????]; 
     var theData : ImageData = 
      new ImageData(theFile.url, (_loader.content as Bitmap).bitmapData); 

     // do something with the data 

     delete completedHandlerLookup[?????? this function ?????]; 
     delete errorHandlerLookup.findByValue(theFile); // [sic] 
    } 

    var theErrorHandler : Function = 
    { 
     var theFile : File = errorHandlerLookup[?????? this function ?????]; 

     // report the error 

     delete errorHandlerLookup[?????? this function ?????]; 
     delete completedHandlerLookup.findByValue(theFile); // [sic] 
    } 

    completedHandlerLookup[theCompletedHandler] = theCompletedHandler; 
    errorHandlerLookup[theCompletedHandler] = theErrorHandler; 

    var theLoader : Loader = new Loader(); 
    theLoader.addEventListener(Event.COMPLETE, theCompletedHandler); 
    theLoader.addEventListener(IOErrorEvent.IO_ERROR, theErrorHandler); 
    theLoader.load(new URLRequest(fileToLoad.url)); 

Puis-je utiliser event.currentTaget et utiliser l'instance du chargeur comme un indice? Cela aura-t-il des dépendances étranges?

Vive

Answer 1

Vous pouvez utiliser

event.currentTarget comme consultation d'index, aussi longtemps que vous clairement toutes vos références, vous devriez avoir aucun problème. Notez toutefois que les écouteurs d'événement loader sont ajoutés à loader.contentLoaderInfo, ce qui permet d'accéder au chargeur via e.currentTarget.loader.

Il convient également de mentionner qu'une approche plus simple de cette situation consiste à créer un système basé sur une file d'attente, de sorte qu'il n'a chargé qu'un seul fichier à la fois. Par exemple, stocker tous les fichiers dans un tableau. Ensuite, sur COMPLETE ou IO_ERROR, vous manipulez le fichier en cours et ensuite le suivant. Ce serait un peu plus sage sur le plan des ressources (un seul chargeur), et évitez les problèmes de récupération de place.

Je suis aussi un peu curieux de savoir pourquoi vous êtes des fonctions anonymes? Ils ne sont pas très bons du point de vue de la collecte des ordures, et compliquent réellement cette situation. Est-ce une exigence? Edit: Voici un exemple approximatif (et incomplet) de la façon dont un système basé sur une file d'attente résoudrait ce problème.

var loader:Loader; 
var queue:Array; 

function addFile(file:File):void 
{ 
    queue.push(file); 
} 

function handleLoadedAsset(e:Event):void 
{ 
    var currentFile:File= queue[0]; 
    //do whatever 
    stepQueueForward(); 
} 

function handleFailedAssetLoad(e:IOErrorEvent):void 
{ 
    var currentFile:File = queue[0]; 
    //clean up 
    stepQueueForward(); 
} 

function stepQueueForward():void 
{ 
    queue.splice(0, 1); 
    var nextFile:File = queue[0]; 
    loader.load(new URLRequest(nextFile.url)); 
}