AS3: classe Singleton vs classe LocalConnection

Question

J'ai une charge de classe principale 2 SWF (chargeur et spectateur, également avec des classes de document). Ils doivent partager un double tampon avec le contenu, bien sûr, rempli par le chargeur et montré par spectateur

Je pensais utiliser la classe LocalConnection mais après une suggestion de PatrickS maintenant j'évalue la possibilité d'une classe Singleton. Je ne l'ai jamais utilisé ce modèle dans AS et dois avouer que je suis plutôt un parti pris contre elle. Mais dans ce cas particulier, je pense que ce sera utile. Soit dit en passant, un peu surpris de lire dans les exemples gskinner blog 2 implémentations. Donc, je vais vraiment apprécier votre point de vue, sachant ce sujet est une guerre sans fin comme le Mac vs PC un

Prendre en compte: 1. AIR application de bureau en cours d'exécution 24x7 pendant quelques mois dans un haut de gamme PC Windows. Aucune interaction utilisateur 2. Code de haute performance est un must, car le contenu chargé sont pleins des images HD

Mon autre préoccupation concerne les fuites de mémoire

Merci à l'avance

Answer 1

Il faut éviter un Singleton, personnellement, comme mis en œuvre régulièrement. Cependant, ayant une seule instance de cet objet tampon est logique. Donc ce que je ferais dans ce cas est d'avoir votre classe principale a créé cet objet. Lorsque le spectateur est chargé, transmettre cet objet. Ensuite, faites la même chose pour le chargeur. Maintenant, les deux partagent votre swfs un objet commun qu'ils pourraient utiliser pour communiquer. Ensuite, vous pouvez appeler des fonctions et faire distribuer des événements si vous voulez (extension EventDispatcher ou la mise en œuvre IEventDispatcher). Ou vous pouvez simplement vous inscrire callbacks si vous voulez (devrait être un peu plus rapide, mais pas sûr si elle va faire une grande différence).

Modifier

Avoir un oeil à votre autre question que je pense que votre problème était lié à obtenir le droit chargeur et transmettre les données au contenu chargé. Voici un skecth de la façon dont vous pourriez mettre en œuvre ce que je l'ai mentionné ci-dessus.

PhotoLoader.swf:

package  {
import flash.display.Sprite;
import flash.events.Event;

public class PhotoLoader extends Sprite {

    private var _commonObject:CommonObject;

    public function PhotoLoader() {

    }

    public function setCommonObject(commonObject:CommonObject):void {
        trace("PhotoLoader::setCommonObject", commonObject);
        _commonObject = commonObject;
        _commonObject.addEventListener(Event.INIT,handleInit);
    }

    private function handleInit(e:Event):void {
        trace("PhotoLoader::handleInit");
    }

}

} 

PhotoViewer.swf:

package  {
    import flash.display.Sprite;
    import flash.events.Event;

    public class PhotoViewer extends Sprite {

        private var _commonObject:CommonObject;

        public function PhotoViewer() {

        }

        public function setCommonObject(commonObject:CommonObject):void {
            trace("PhotoLoader::setCommonObject", commonObject);
            _commonObject = commonObject;
            _commonObject.addEventListener(Event.INIT,handleInit);
        }

        private function handleInit(e:Event):void {
            trace("PhotoViewer::handleInit");
        }

    }

}

main.swf

package {
    import flash.display.Loader;
    import flash.display.LoaderInfo;
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.net.URLRequest;
    import flash.system.ApplicationDomain;
    import flash.system.LoaderContext;

    public class Main extends Sprite {

        private var _photoLoader:PhotoLoader;
        private var _photoViewer:PhotoViewer;
        private var _commonObject:CommonObject;

        private var _viewerLoader:Loader;
        private var _loaderLoader:Loader;

        private var _count:int = 0;

        public function Main():void {
            _commonObject = new CommonObject();
            loadSwfs();

        }

        private function loadSwfs():void {

            _viewerLoader = new Loader();
            _viewerLoader.contentLoaderInfo.addEventListener(Event.INIT,handleInit);
            _viewerLoader.load(new URLRequest("PhotoViewer.swf"));

            _loaderLoader = new Loader();
            _loaderLoader.contentLoaderInfo.addEventListener(Event.INIT,handleInit);
            _loaderLoader.load(new URLRequest("PhotoLoader.swf"));

        }

        private function handleInit(e:Event):void {
            trace("handleInit");
            var loader:Loader = (e.target as LoaderInfo).loader;
            switch(loader) {
                case _viewerLoader:
                    _photoViewer = _viewerLoader.content as PhotoViewer; 
                    _photoViewer.setCommonObject(_commonObject);
                    _count++;
                    break;
                case _loaderLoader:
                    _photoLoader = _loaderLoader.content as PhotoLoader; 
                    _photoLoader.setCommonObject(_commonObject);
                    _count++;
                    break;
            }
            if(_count == 2) { 
                _commonObject.init();
            }

        }


    }

}

Et l'objet commun, partagé par les 3 swf:

package  {
    import flash.events.Event;
    import flash.events.EventDispatcher;

    public class CommonObject extends EventDispatcher {

        public function CommonObject() {

        }

        public function init():void {
            dispatchEvent(new Event(Event.INIT));
        }
    }

}

En gros lorsque vous chargez à la fois votre lecteur et chargeur swfs vous passez une instance de cet objet commun. Ensuite, vous vous inscrivez pour écouter une méthode INIT: ceci indiquera chargeur et le spectateur que tout a été mis en place. Donc, à ce stade, vous pouvez commencer à envoyer des messages à partir de votre lecteur ou un chargeur à l'autre partie (vous pouvez mettre en œuvre ce par le biais dispatching d'événements); faire essentiellement une méthode dans l'objet commun de le faire pour vous ou tout simplement appeler dispatchEvent sur l'objet commun directement.