Operazioni con i domini applicazione

Flash Player 9 e versioni successive, Adobe AIR 1.0 e versioni successive

Lo scopo della classe ApplicationDomain è quello di consentire la memorizzazione di una tabella di definizioni di ActionScript 3.0. Tutto il codice presente in un file SWF viene definito per esistere in un dominio applicazione. 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 di riutilizzare le definizioni degli elementi principali da parte degli elementi secondari.

I domini delle applicazioni possono essere utilizzati quando si carica un file SWF esterno scritto in ActionScript 3.0 utilizzando l'API della classe Loader. Non è possibile utilizzare i domini delle applicazioni quando si carica un'immagine o un file SWF scritto in ActionScript 1.0 o ActionScript 2.0. Tutte le definizioni di ActionScript 3.0 contenute nella classe Loader vengono salvate nel dominio dell'applicazione. Quando si carica il file SWF, è possibile specificare che venga incluso nello stesso dominio dell'applicazione che contiene l'oggetto Loader impostando il parametro applicationDomain dell'oggetto LoaderContext su ApplicationDomain.currentDomain. L'inserimento del file SWF caricato nello stesso dominio dell'applicazione consente di accedere direttamente alle relative classi. Ciò può essere utile se caricate un SWF che include contenuto multimediale incorporato a cui è possibile accedere tramite i nomi delle classi associate oppure se desiderate accedere ai metodi del file SWF caricato.

Nell'esempio seguente si presume che sia accessibile un file Greeter.swf distinto che definisce un metodo pubblico denominato welcome():

package 
{ 
    import flash.display.Loader; 
    import flash.display.Sprite; 
    import flash.events.*; 
    import flash.net.URLRequest; 
    import flash.system.ApplicationDomain; 
    import flash.system.LoaderContext; 
 
    public class ApplicationDomainExample extends Sprite 
    { 
        private var ldr:Loader; 
        public function ApplicationDomainExample() 
        { 
            ldr = new Loader(); 
            var req:URLRequest = new URLRequest("Greeter.swf"); 
            var ldrContext:LoaderContext = new LoaderContext(false, ApplicationDomain.currentDomain); 
            ldr.contentLoaderInfo.addEventListener(Event.COMPLETE, completeHandler); 
            ldr.load(req, ldrContext);     
        } 
        private function completeHandler(event:Event):void 
        { 
            var myGreeter:Class = ApplicationDomain.currentDomain.getDefinition("Greeter") as Class; 
            var myGreeter:Greeter = Greeter(event.target.content); 
            var message:String = myGreeter.welcome("Tommy"); 
            trace(message); // Hello, Tommy 
        } 
    } 
}

Inoltre, vedete Esempio classe ApplicationDomain della Guida di riferimento di Adobe ActionScript 3.0 per la piattaforma Adobe Flash.

Di seguito sono elencati altri aspetti da considerare quando si utilizzano i domini dell'applicazione:

  • Tutto il codice presente in un file SWF viene definito per esistere in un dominio applicazione. Il dominio 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 dell'applicazione, eccetto il 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 loro elemento principale. Non è consentito ridefinire la definizione di una classe caricata.

Nel diagramma seguente è illustrata un'applicazione che carica il contenuto da diversi file SWF all'interno di un unico dominio, domain1.com. A seconda del contenuto caricato, possono essere utilizzati diversi domini dell'applicazione. Il testo seguente descrive la logica utilizzata per impostare il dominio dell'applicazione corretto per ogni file SWF incluso nell'applicazione.

Il file dell'applicazione principale è application1.swf. Contiene gli oggetti Loader che caricano il contenuto da altri file SWF. In questo scenario, il dominio corrente è Dominio applicazione 1. Uso A, Uso B e Uso C illustrano le diverse tecniche per impostare il dominio dell'applicazione appropriato per ogni file SWF incluso in un'applicazione.

Uso A:
separazione in partizioni del file SWF secondario creando un dominio di sistema secondario. Nel diagramma viene creato Dominio applicazione 2 come elemento secondario del dominio di sistema. Il file application2.swf viene caricato nel Dominio applicazione 2 e le relative definizioni di classe vengono in tal modo separate in partizioni dalle classi definite nel file application1.swf.

Questa tecnica può essere utilizzata, ad esempio, per fare in modo che un'applicazione datata carichi dinamicamente una versione più recente della stessa applicazione senza creare conflitti. Il conflitto non avviene perché nonostante vengano utilizzati gli stessi nomi di classe, questi sono separati in partizioni in domini dell'applicazione diversi.

Il codice seguente crea un dominio dell'applicazione secondario rispetto al dominio di sistema e comincia a caricare il file SWF utilizzando questo particolare dominio:

var appDomainA:ApplicationDomain = new ApplicationDomain(); 
 
var contextA:LoaderContext = new LoaderContext(false, appDomainA); 
var loaderA:Loader = new Loader(); 
loaderA.load(new URLRequest("application2.swf"), contextA);

Uso B:
aggiunta di nuove definizioni di classe alle definizioni di classe correnti. Il dominio dell'applicazione del file module1.swf è impostato sul dominio corrente (Dominio applicazione 1). Ciò consente di aggiungere le nuove definizioni di classe al set di definizioni di classe corrente dell'applicazione. Questo approccio può essere utilizzato per una libreria condivisa in runtime dell'applicazione principale. Il file SWF caricato viene gestito come una libreria condivisa remota (RSL). Utilizzare questa tecnica per caricare le RSL mediante un precaricatore prima dell'avvio dell'applicazione.

Il seguente codice carica un file SWF e imposta il suo dominio dell'applicazione sul dominio corrente:

var appDomainB:ApplicationDomain = ApplicationDomain.currentDomain; 
 
var contextB:LoaderContext = new LoaderContext(false, appDomainB); 
var loaderB:Loader = new Loader(); 
loaderB.load(new URLRequest("module1.swf"), contextB);

Uso C:
uso delle definizioni di classe dell'elemento principale mediante la creazione di un nuovo dominio secondario del dominio corrente. Il dominio dell'applicazione del file module3.swf è un elemento secondario del dominio corrente e tale elemento secondario utilizza le versioni di tutte le classi dell'elemento principale. Questa tecnica può inoltre essere utilizzata, ad esempio, per caricare un modulo di un'applicazione RIA (Rich Internet Application) con più schermate come elemento secondario dell'applicazione principale, che utilizza i tipi dell'applicazione principale. Se è possibile garantire che tutte le classi siano sempre aggiornate ai fini della compatibilità con le versioni precedenti e che l'applicazione che effettua il caricamento sia sempre più recente degli elementi caricati, l'elemento secondario utilizzerà le versioni principali. La disponibilità di un nuovo dominio dell'applicazione consente inoltre di scaricare tutte le definizioni di classe per il processo di garbage collection, a condizione che sia possibile garantire che non si continuerà a utilizzare riferimenti al file SWF secondario.

Questa tecnica consente ai moduli caricati di condividere gli oggetti singleton del caricatore e i membri delle classi statici.

Il codice seguente crea un nuovo dominio secondario all'interno del dominio corrente e comincia a caricare il file SWF utilizzando questo particolare dominio:

var appDomainC:ApplicationDomain = new ApplicationDomain(ApplicationDomain.currentDomain); 
 
var contextC:LoaderContext = new LoaderContext(false, appDomainC); 
var loaderC:Loader = new Loader(); 
loaderC.load(new URLRequest("module3.swf"), contextC);