Arbeta med programdomäner

Flash Player 9 och senare, Adobe AIR 1.0 och senare

Syftet med klassen ApplicationDomain är att lagra en tabell med ActionScript 3.0-definitioner. All kod i en SWF-fil är definierad för att finnas i en programdomän. Programdomäner används för att partitionera klasser inom samma säkerhetsdomän. Detta gör det möjligt att använda flera definitioner av samma klass samt att underordnade klasser kan återanvända överordnade klassers definitioner.

Du kan använda programdomäner när du läser in en extern SWF-fil som har skrivits i ActionScript 3.0 med hjälp av API:et för klassen Loader. (Observera att du inte kan använda programdomäner för att läsa in en bild eller SWF-fil som har skrivits i ActionScript 1.0 eller ActionScript 2.0.) Alla ActionScript 3.0-definitioner som ingår i den inlästa klassen lagras i programdomänen. När du läser in SWF-filen kan du ange att filen ska inkluderas i samma programdomän som den för Loader-objektet. Det gör du genom att ställa in parametern applicationDomain för LoaderContext-objektet på ApplicationDomain.currentDomain. Genom att placera den inlästa SWF-filen i samma programdomän får du direktåtkomst till klasserna. Det är praktiskt om du läser in en SWF-fil som innehåller inbäddat medieinnehåll som du kan nå via det tillhörande klassnamnet eller om du vill nå den inlästa SWF-filens metoder.

I exemplet nedan har den har åtkomst till en separat Greeter.swf-fil som definierar en publik metod med namnet 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 
        } 
    } 
}

Se även Exempel på klassen ApplicationDomain i Referenshandbok för ActionScript 3.0 i Adobe Flash-plattformen.

Du bör också tänka på följande när du arbetar med programdomäner:

All kod i en SWF-fil är definierad för att finnas i en programdomän. Den aktuella domänen är den där huvudprogrammet körs. Systemdomänen innehåller alla programdomäner, inklusive den aktuella domänen, vilket betyder att den innehåller alla Flash Player-klasser.
Alla programdomäner utom systemdomänen har en överordnad domän. Den överordnade domänen för huvudprogrammets programdomän är systemdomänen. Inlästa klasser definieras bara om de inte redan är definierade av sina överordnade klasser. Du kan inte åsidosätta en inläst klassdefinition med en nyare definition.

I nedanstående diagram visas ett program som läser in innehållet från olika SWF-filer i en enda domän, domain1.com. Beroende på vilket innehåll du läser in kan olika programdomäner användas. I den följande texten beskrivs logiken som används för att ställa in lämplig programdomän för varje SWF-fil i programmet.

Visa grafik i full storlek

A.: Användning A
B.: Användning B
C.: Användning C

Huvudprogramfilen är application1.swf. Den innehåller Loader-objekt som läser in innehåll från andra SWF-filer. Enligt detta scenario är den aktuella domänen programdomän 1. Användning A, B och C illustrerar olika tekniker för att ställa in lämplig domän för varje SWF-fil i ett program.

Användning A

Partitionera den underordnade SWF-filen genom att skapa en underordnad till systemdomänen. I diagrammet skapas programdomän 2 som underordnad till systemdomänen. Filen application2.swf läses in i programdomän 2, och dess klassdefinitioner partitioneras därmed från klasserna som är definierade i application1.swf.

Den här tekniken kan till exempel användas om du vill att ett äldre program dynamiskt ska läsa in en nyare version av samma program utan att någon konflikt uppstår. Även om samma klassnamn används uppstår ingen konflikt eftersom de är partitionerade i olika programdomäner.

I följande kod skapas en programdomän som är underordnad till systemdomänen, och en SWF-fil som använder den programdomänen börjar att läsas in:

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

Användning B:

Lägga till nya klassdefinitioner till de aktuella klassdefinitionerna. Programdomänen för module1.swf är inställd på den aktuella domänen (programdomän 1). Det gör att du kan lägga till nya klassdefinitioner till programmets aktuella uppsättning med klassdefinitioner. Detta kan användas för ett delat körtidsbibliotek för huvudprogrammet. Den inlästa SWF-filen behandlas som ett fjärranslutet delat bibliotek (RSL). Använd den här tekniken om du vill läsa in RSL:er på förhand innan programmet startar.

I följande kod läses en SWF-fil in och programdomänen ställs in på den aktuella domänen:

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

Användning C:

Använda de överordnade klassdefinitionerna genom att skapa en ny underordnad domän till den aktuella domänen. Programdomänen för module3.swf är underordnad den aktuella domänen, och den underordnade domänen använder den överordnade domänens versioner av samtliga klasser. Den här tekniken kan till exempel användas som en modul för RIA-program med flera skärmar som läses in som underordnad till huvudprogrammet, och använder huvudprogrammets typer. Om du kan se till att alla klasser alltid är uppdaterade och bakåtkompatibla, och att inläsningsprogrammet alltid är nyare än det som ska läsas in, kommer underordnade att använda de överordnades versioner. Genom att ha en ny programdomän kan du även ta bort alla klassdefinitioner för skräpsamling, om du kan se till att du inte fortsätter att ha referenser till den underordnade SWF-filen.

Den här tekniken gör att inlästa moduler kan dela inläsarens Singleton-objekt och statiska klassmedlemmar.

I följande kod skapas en ny underordnad domän till den aktuella domänen och en SWF-fil börjar läsas in med programdomänen:

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