AS3: Singleton Klasse vs Localconnection-Klasse

Question

Ich habe eine Hauptklasse Laden 2 SWF (Lader und Betrachter, auch mit Dokumentklassen). Sie brauchen einen Doppelpuffer mit Inhalt zu teilen, natürlich, gefüllt mit Lader und zeigte durch Betrachter

Ich dachte, die Localconnection-Klasse zu verwenden, aber nach einem Vorschlag von Patrick jetzt ist ich die Bewertung der Möglichkeit einer Singleton-Klasse. Ich habe noch nie dieses Muster in AS verwendet und muss gestehen, ich bin eher voreingenommen gegen sie. Aber in diesem speziellen Fall ich denke, es nützlich sein wird. By the way, überrascht ein wenig in der gskinner Lesen 2 Implementierungen Beispiele bloggen. Also, ich werde wirklich Ihre Ansichten zu schätzen wissen, zu diesem Thema zu wissen, ist ein endloser Krieg wie der Mac vs PC einen

Beachten Sie: 1. AIR Desktop-Anwendung 24x7 während einiger Monate in einem High-End-Windows-PC ausgeführt wird. Kein Benutzereingriff 2. Hohe Performance-Code ist ein Muss, weil geladen Inhalt Full-HD-Bilder

sind

Meine andere Sorge ist, um Speicherlecks

Vielen Dank im Voraus

Answer 1

würde ich ein Singleton, persönlich vermeiden, als regelmäßig umgesetzt. Jedoch macht es Sinn, eine einzelne Instanz dieses Puffers Objekt mit. Also, was ich in diesem Fall tun würde, ist, Ihre Hauptklasse dieses Objekt erstellt. Wenn der Zuschauer geladen wird, gibt sie diese Aufgabe. Dann das gleiche für den Lader. Nun, beide Ihre swfs teilen ein gemeinsames Ziel, dass sie kommunizieren zu können. Dann können Sie Funktionen auf sie anrufen und machen es Ereignisse auslösen, wenn Sie wollen (Erweiterung Eventdispatcher oder Umsetzung IEventDispatcher). Oder Sie können einfach Rückrufe registrieren, wenn Sie wollen (sollten etwas schneller sein, aber nicht sicher, ob es wird einen großen Unterschied machen).

Bearbeiten

einen Blick auf Ihrer anderen Frage Nachdem ich denke, Ihr Problem den richtigen Kran zu bekommen und Übergabe von Daten an den geladenen Inhalt verwendet war. Hier ist ein skecth, wie Sie könnte das umzusetzen, was ich oben erwähnt.

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

        }


    }

}

Und das gemeinsame Ziel, durch die 3 swf geteilt:

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

}

Im Grunde genommen, wenn Sie sowohl Ihre Viewer laden und Lader swfs Sie eine Instanz dieses gemeinsamen Objekt. Dann registrieren Sie sich für eine INIT-Methode zu hören: dieses Laders sagen wird und Betrachter, dass alles eingerichtet wurde. Deshalb an dieser Stelle können Sie beginnen, Nachrichten von Ihrem Viewer oder Lader an die andere Partei zu senden (man könnte dies durch Event-Dispatching implementieren); im Grunde macht ein Verfahren, in dem gemeinsamen Objekt, um es für Sie zu tun oder einfach nur direkt dispatch auf dem gemeinsamen Objekt aufrufe.