flash.system.ApplicationDomain (ActionScript 3.0)

Pacchetto	flash.system
Classe	public final class ApplicationDomain
Ereditarietà	ApplicationDomain Object

Versione linguaggio:

ActionScript 3.0

Versione lettore:

Flash Player 9

La classe ApplicationDomain è un contenitore per gruppi separati di definizioni di classi. I domini delle applicazioni sono utilizzati per separare in partizioni le classi che si trovano nello stesso dominio di sicurezza. Consentono di avere più definizioni per la stessa classe e il riutilizzo delle definizioni degli elementi principali da parte degli elementi secondari.

I domini delle applicazioni vengono utilizzati quando un file SWF esterno viene caricato mediante la classe Loader. Tutte le definizioni di ActionScript 3.0 nel file SWF caricato vengono salvate nel dominio dell'applicazione specificato dalla proprietàapplicationDomain dell'oggetto LoaderContext che viene passato come parametro context del metodo load() o loadBytes() dell'oggetto Loader. L'oggetto LoaderInfo contiene anche una proprietà applicationDomain di sola lettura.

Tutto il codice presente in un file SWF viene definito come esistente all'interno di un dominio dell'applicazione. Il dominio applicazione corrente è quello in cui viene eseguita l'applicazione principale. Il dominio di sistema contiene tutti i domini dell'applicazione, compreso quello corrente; in altri termini, contiene tutte le classi di Flash Player.

Tutti i domini applicazioni, ad eccezione del dominio di sistema, sono associati a un dominio principale. Il dominio principale del dominio applicazione dell'applicazione principale è il dominio di sistema. Le classi caricate vengono definite soltanto se non sono già definite dal rispettivo elemento principale. Non è possibile sostituire la definizione di una classe caricata.

Per alcuni esempi dell'utilizzo dei domini applicazioni, vedere Programmazione in ActionScript 3.0.

La funzione di costruzione ApplicationDomain() consente di creare un oggetto ApplicationDomain.

Vedere gli esempi

Vedere anche

flash.display.Loader.load()
flash.display.Loader.loadBytes()
flash.display.LoaderInfo
flash.net.URLRequest
flash.system.LoaderContext
Uso della classe ApplicationDomain

	Proprietà	Definito da
		constructor: Object Un riferimento all'oggetto classe o alla funzione di costruzione per una determinata istanza di oggetto.	Object
		currentDomain: ApplicationDomain [statico] [sola lettura] Ottiene il dominio applicazione corrente nel quale viene eseguito il codice.	ApplicationDomain
		parentDomain: ApplicationDomain [sola lettura] Ottiene il dominio principale di questo dominio applicazione.	ApplicationDomain
		prototype: Object [statico] Un riferimento all'oggetto prototipo di un oggetto classe o funzione.	Object

	Metodo	Definito da
		ApplicationDomain(parentDomain:ApplicationDomain = null) Crea un nuovo dominio applicazione.	ApplicationDomain
		getDefinition(name:String):Object Ottiene una definizione pubblica dal dominio applicazione specificato.	ApplicationDomain
		hasDefinition(name:String):Boolean Verifica se nel dominio applicazione specificato è presente una definizione pubblica.	ApplicationDomain
		hasOwnProperty(name:String):Boolean Indica se per un oggetto è definita una proprietà specifica.	Object
		isPrototypeOf(theClass:Object):Boolean Indica se un'istanza della classe Object si trova nella catena di prototipi dell'oggetto specificato come parametro.	Object
		propertyIsEnumerable(name:String):Boolean Indica se la proprietà specificata esiste ed è enumerabile.	Object
		setPropertyIsEnumerable(name:String, isEnum:Boolean = true):void Imposta la disponibilità di una proprietà dinamica per le operazioni cicliche.	Object
		toString():String Restituisce la rappresentazione in formato stringa dell'oggetto specificato.	Object
		valueOf():Object Restituisce il valore di base dell'oggetto specificato.	Object

Descrizione delle proprietà

currentDomain

proprietà

currentDomain:ApplicationDomain [sola lettura]

Versione linguaggio:

ActionScript 3.0

Versione lettore:

Flash Player 9

Ottiene il dominio applicazione corrente nel quale viene eseguito il codice.

Implementazione
public static function get currentDomain():ApplicationDomain

Vedere anche

Uso della classe ApplicationDomain

parentDomain

proprietà

parentDomain:ApplicationDomain [sola lettura]

Versione linguaggio:

ActionScript 3.0

Versione lettore:

Flash Player 9

Ottiene il dominio principale di questo dominio applicazione.

Implementazione
public function get parentDomain():ApplicationDomain

Vedere anche

Uso della classe ApplicationDomain

Descrizione della funzione di costruzione

ApplicationDomain

()

Funzione di costruzione

public function ApplicationDomain(parentDomain:ApplicationDomain = null)

Versione linguaggio:

ActionScript 3.0

Versione lettore:

Flash Player 9

Crea un nuovo dominio applicazione.

Parametri

parentDomain:ApplicationDomain (default = null) — Se non viene passato alcun dominio principale, questo dominio applicazione adotta il dominio di sistema come proprio elemento principale.

Descrizione dei metodi

getDefinition

()

metodo

public function getDefinition(name:String):Object

Versione linguaggio:

ActionScript 3.0

Versione lettore:

Flash Player 9

Ottiene una definizione pubblica dal dominio applicazione specificato. La definizione può essere di una classe, di uno spazio dei nomi o di una funzione.

Parametri

name:String — Il nome della definizione.

Restituisce

Object — L'oggetto associato alla definizione.

Genera

ReferenceError — Non esiste una definizione pubblica con il nome specificato.

hasDefinition

()

metodo

public function hasDefinition(name:String):Boolean

Versione linguaggio:

ActionScript 3.0

Versione lettore:

Flash Player 9

Verifica se nel dominio applicazione specificato è presente una definizione pubblica. La definizione può essere di una classe, di uno spazio dei nomi o di una funzione.

Parametri

name:String — Il nome della definizione.

Restituisce

Boolean — Un valore true se la definizione specificata esiste; false in caso contrario.

Esempi Come utilizzare gli esempi

ApplicationDomainExample.as

L'esempio seguente mostra il modo in cui è possibile caricare la classe in fase di runtime e chiamare i metodi pubblici di una classe che si trova in un altro file SWF.

Note:

Poiché la classe ClassLoader carica un file SWF, è necessario impostare la sicurezza locale a livello di file system.
Per provare questo esempio, è necessario che sia disponibile un file swf denominato RuntimeClasses.swf nella stessa cartella del file ApplicationDomainExample.swf.

Creare innanzitutto il file RuntimeClasses.swf utilizzando il codice seguente:

 package {
    import flash.display.Sprite;

    public class RuntimeClasses extends Sprite
    {
        public function RuntimeClasses()
        {
        }
        
        public function greet():String {
            return("Hello World");
        }
    }
}

Quindi, implementare il codice seguente:


package {
    import flash.display.DisplayObject;
    import flash.display.Sprite;
    import flash.errors.IllegalOperationError;
    import flash.events.Event;
    import flash.text.TextField;

    public class ApplicationDomainExample extends Sprite {
        private var loader:ClassLoader;
        private var tf:TextField = new TextField();

        public function ApplicationDomainExample() {
            addChild(tf);

            loader = new ClassLoader();
            loader.addEventListener(ClassLoader.LOAD_ERROR,loadErrorHandler);
            loader.addEventListener(ClassLoader.CLASS_LOADED,classLoadedHandler);
            loader.load("RuntimeClasses.swf");
        }

        private function loadErrorHandler(e:Event):void {
            tf.text = "Load failed";
            throw new IllegalOperationError("Cannot load the specified file.");
        }

        private function classLoadedHandler(e:Event):void {
            var runtimeClassRef:Class = loader.getClass("RuntimeClasses");
            var greeter:Object = new runtimeClassRef();

            tf.text = greeter.greet();
        }
    }
}

import flash.display.Loader;
import flash.errors.IllegalOperationError;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.IOErrorEvent;
import flash.events.SecurityErrorEvent;
import flash.net.URLRequest;
import flash.system.ApplicationDomain;
import flash.system.LoaderContext;

class ClassLoader extends EventDispatcher {
    public static var CLASS_LOADED:String = "classLoaded";
    public static var LOAD_ERROR:String = "loadError";
    private var loader:Loader;
    private var swfLib:String;
    private var request:URLRequest;
    private var loadedClass:Class;

    public function ClassLoader() {

        loader = new Loader();
        loader.contentLoaderInfo.addEventListener(Event.COMPLETE,completeHandler);
        loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler);
        loader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,securityErrorHandler);
    }

    public function load(lib:String):void {
        swfLib = lib;
        request = new URLRequest(swfLib);
        var context:LoaderContext = new LoaderContext();
        context.applicationDomain=ApplicationDomain.currentDomain;
        loader.load(request,context);
    }

    public function getClass(className:String):Class {
        try {
            return loader.contentLoaderInfo.applicationDomain.getDefinition(className)  as  Class;
        } catch (e:Error) {
            throw new IllegalOperationError(className + " definition not found in " + swfLib);
        }
        return null;
    }

    private function completeHandler(e:Event):void {
        dispatchEvent(new Event(ClassLoader.CLASS_LOADED));
    }

    private function ioErrorHandler(e:Event):void {
        dispatchEvent(new Event(ClassLoader.LOAD_ERROR));
    }

    private function securityErrorHandler(e:Event):void {
        dispatchEvent(new Event(ClassLoader.LOAD_ERROR));
    }
}

ApplicationDomainExample.2.as

Se più file SWF contengono classi compilate con lo stesso nome ma con implementazione diversa, è possibile separare in partizioni le classi dei file SWF caricati esternamente in modo distinto dalle classi degli altri file sulla base di questo esempio. In precedenza, al file SWF secondario veniva indicato di utilizzare ApplicationDomain.currentDomain. In questo caso viene creato un nuovo ApplicationDomain in modo che le proprietà e i metodi della classe Greeter del file SWF che viene caricato per secondo non sostituiscano le proprietà e i metodi della prima classe Greeter. È possibile verificare questa circostanza modificando la proprietà context.applicationDomain nel metodo load di ClassLoader.

Note:

Poiché la classe ClassLoader carica un file SWF, è necessario impostare la sicurezza locale a livello di file system.
Per provare questo esempio, è necessario disporre di due file SWF denominati Greeter.swf contenuti in una cartella "en" ed "es" rispettivamente.

Creare un file Greeter.as nella directory "en" con il codice seguente:

 package {
    import flash.display.Sprite;

    public class Greeter extends Sprite
    {
        public function Greeter()
        {
        }
        
        public function greet():String {
            return("Good Morning");
        }
    }
}

Quindi creare un file Greeter.as molto simile nella directory "es":

 package {
    import flash.display.Sprite;

    public class Greeter extends Sprite
    {
        public function Greeter()
        {
        }
        
        public function greet():String {
            return("Buenos Dias");
        }
    }
}

Compilare i file SWF per entrambi i file e quindi implementare il codice seguente:

package {
    import flash.display.DisplayObject;
    import flash.display.Sprite;
    import flash.errors.IllegalOperationError;
    import flash.events.Event;
    import flash.text.TextField;
    import flash.text.TextFieldAutoSize;

    public class ApplicationDomainExample2 extends Sprite {
        private var spanishGreeterLoader:ClassLoader;
        private var englishGreeterLoader:ClassLoader;
        private var tf:TextField = new TextField();
        private var greetersLoaded:uint = 0;

        public function ApplicationDomainExample2() {
            tf.autoSize = TextFieldAutoSize.LEFT;
            addChild(tf);

            spanishGreeterLoader = new ClassLoader();
            spanishGreeterLoader.addEventListener(ClassLoader.LOAD_ERROR,loadErrorHandler);
            spanishGreeterLoader.addEventListener(ClassLoader.CLASS_LOADED,classLoadedHandler);
            spanishGreeterLoader.load("es/Greeter.swf");
            
            englishGreeterLoader = new ClassLoader();
            englishGreeterLoader.addEventListener(ClassLoader.LOAD_ERROR,loadErrorHandler);
            englishGreeterLoader.addEventListener(ClassLoader.CLASS_LOADED,classLoadedHandler);
            englishGreeterLoader.load("en/Greeter.swf");
        }

        private function loadErrorHandler(e:Event):void {
            tf.text = "Load failed";
            throw new IllegalOperationError("Cannot load the specified file.");
        }

        private function classLoadedHandler(e:Event):void {
            greetersLoaded++;
            if(greetersLoaded == 2) {
                greet();    
            }
        }
        
        private function greet():void {
            var spanishGreeter:Class = spanishGreeterLoader.getClass("Greeter");
            var englishGreeter:Class = englishGreeterLoader.getClass("Greeter");
            var greeter1 = new spanishGreeter();
            var greeter2 = new englishGreeter();
            
            tf.text = greeter1.greet() + "\n" + greeter2.greet();
        }
    }
}

import flash.display.Loader;
import flash.errors.IllegalOperationError;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.IOErrorEvent;
import flash.events.SecurityErrorEvent;
import flash.net.URLRequest;
import flash.system.ApplicationDomain;
import flash.system.LoaderContext;

class ClassLoader extends EventDispatcher {
    public static var CLASS_LOADED:String = "classLoaded";
    public static var LOAD_ERROR:String = "loadError";
    private var loader:Loader;
    private var swfLib:String;
    private var request:URLRequest;
    private var loadedClass:Class;

    public function ClassLoader() {

        loader = new Loader();
        loader.contentLoaderInfo.addEventListener(Event.COMPLETE,completeHandler);
        loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler);
        loader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,securityErrorHandler);
    }

    public function load(lib:String):void {
        swfLib = lib;
        request = new URLRequest(swfLib);
        var context:LoaderContext = new LoaderContext();
//        context.applicationDomain = ApplicationDomain.currentDomain;
        context.applicationDomain = new ApplicationDomain();
        loader.load(request,context);
    }

    public function getClass(className:String):Class {
        try {
            return loader.contentLoaderInfo.applicationDomain.getDefinition(className)  as  Class;
        } catch (e:Error) {
            throw new IllegalOperationError(className + " definition not found in " + swfLib);
        }
        return null;
    }

    private function completeHandler(e:Event):void {
        dispatchEvent(new Event(ClassLoader.CLASS_LOADED));
    }

    private function ioErrorHandler(e:Event):void {
        dispatchEvent(new Event(ClassLoader.LOAD_ERROR));
    }

    private function securityErrorHandler(e:Event):void {
        dispatchEvent(new Event(ClassLoader.LOAD_ERROR));
    }
}

Pagina corrente: http://livedocs.adobe.com/flash/9.0_it/ActionScriptLangRefV3/flash/system/ApplicationDomain.html

Guida di riferimento del linguaggio e dei componenti ActionScript 3.0		Tutti i pacchetti \| Tutte le classi \| Elementi del linguaggio \| Indice \| Appendici \| Convenzioni \| Con frame Senza frame
ApplicationDomain	Proprietà \| Metodi \| Esempi