Definieren von Namespaces

Namespaces enthalten einen Wert, den Uniform Resource Identifier (URI), der manchmal auch als Namespace-Name bezeichnet wird. Mit einem URI können Sie sicherstellen, dass Ihre Namespace-Definition einmalig ist.

Ein Namespace wird durch das Deklarieren einer Namespace-Definition erstellt. Dabei stehen Ihnen zwei Verfahren zur Verfügung: Entweder definieren Sie einen Namespace mit einem expliziten URI, als ob Sie einen XML-Namespace definieren würden, oder Sie lassen den URI weg. Das folgende Beispiel zeigt, wie ein Namespace mit einem URI definiert wird:

namespace flash_proxy = "http://www.adobe.com/flash/proxy";

Der URI dient als eindeutiger Identifikationsstring für diesen Namespace. Wenn Sie den URI weglassen, erstellt der Compiler einen eindeutigen internen Identifikationsstring anstelle des URI, wie im folgenden Beispiel dargestellt. Sie können nicht auf diesen internen Identifikationsstring zugreifen.

namespace flash_proxy;

Nach der Definition eines Namespace – ob mit oder ohne URI – kann dieser Namespace im gleichen Gültigkeitsbereich nicht mehr neu definiert werden. Der Versuch, einen Namespace zu definieren, obwohl schon ein Namespace im gleichen Gültigkeitsbereich existiert, führt zu einem Compiler-Fehler.

Ein in einem Paket oder einer Klasse definierter Namespace ist für Code außerhalb des Pakets oder der Klasse nicht sichtbar, es sei denn, es wird der entsprechende Zugriffskontrollbezeichner verwendet. Beispielsweise wurde der Namespace flash_proxy im folgenden Code im flash.utils-Paket definiert. Im folgenden Code bedeutet das Fehlen eines Zugriffskontrollbezeichners, dass der Namespace flash_proxy nur für Code innerhalb des flash.utils-Paket und nicht für Code außerhalb des Pakets sichtbar ist:

package flash.utils 
{ 
    namespace flash_proxy; 
}

Im folgenden Code wird das public-Attribut verwendet, um den flash_proxy-Namespace auch für Code außerhalb des Pakets sichtbar zu machen:

package flash.utils 
{ 
    public namespace flash_proxy; 
}

Anwenden von Namespaces

Unter Anwenden eines Namespace ist das Platzieren einer Definition in einem Namespace zu verstehen. In Namespaces können Funktionen, Variablen und Konstanten platziert werden (das Platzieren einer Klasse in einem benutzerdefinierten Namespace ist nicht möglich).

Betrachten Sie das Beispiel einer Funktion, die mit dem Zugriffskontroll-Namespace public deklariert wurde. Mit dem public-Attribut in einer Funktionsdefinition wird die Funktion in einem öffentlichen (public) Namespace platziert, wodurch die Funktion für jeden Code verfügbar ist. Ein definierter Namespace kann auf die gleiche Weise wie das public-Attribut verwendet werden, und die Definition ist für Code verfügbar, der auf Ihren benutzerdefinierten Namespace verweisen kann. Angenommen Sie haben einen Namespace example1 definiert, so können Sie eine Methode mit der Bezeichnung myFunction() mit dem Attribut example1 hinzufügen. Dies wird im folgenden Beispiel gezeigt:

namespace example1; 
class someClass 
{ 
    example1 myFunction() {} 
}

Das Deklarieren der myFunction()-Methode mit dem Namespace example1 als Attribut bedeutet, dass die Methode zum Namespace example1 gehört.

Beim Anwenden von Namespaces müssen Sie Folgendes berücksichtigen:

• Sie können in jeder Deklaration nur einen Namespace anwenden.

• Es gibt keine Möglichkeit, ein Namespace-Attribut auf mehrere Definitionen gleichzeitig anzuwenden. Mit anderen Worten, wenn Sie Ihren Namespace auf zehn verschiedene Funktionen anwenden möchten, müssen Sie Ihren Namespace jeder dieser zehn Funktionsdefinitionen hinzufügen.

• Beim Anwenden eines Namespace können Sie keinen Zugriffskontrollbezeichner angeben, da sich Namespaces und Zugriffskontrollbezeichner gegenseitig ausschließen. Sie können also eine Funktion oder Eigenschaft zusätzlich zum Anwenden Ihres Namespace nicht als public, private, protected oder internal deklarieren.

Referenzieren von Namespaces

Wenn Sie eine Methode oder Eigenschaft verwenden, die mit einem der Zugriffskontroll-Namespaces wie public, private, protected und internal deklariert wurde, ist kein expliziter Verweis auf einen Namespace mehr erforderlich. Dies liegt daran, dass der Zugriff auf diese speziellen Namespaces über den Kontext gesteuert wird. Im Namespace private platzierte Definitionen stehen beispielsweise automatisch für Code in der gleichen Klasse zur Verfügung. Für benutzerdefinierte Namespaces existiert eine solche Kontextempfindlichkeit jedoch nicht. Um eine von Ihnen in einem benutzerdefinierten Namespace platzierte Methode oder Eigenschaft zu verwenden, müssen Sie den Namespace referenzieren.

Verweise auf Namespaces erstellen Sie mit der Direktive use namespace, oder Sie qualifizieren den Namen mit dem Namensqualifizierter (::). Das Referenzieren eines Namespace mit der Direktive use namespace „öffnet“ den Namespace, sodass er auf alle nicht qualifizierten Bezeichner angewendet werden kann. Angenommen Sie haben den Namespace example1 definiert, so können Sie mithilfe von use namespace example1 auf Namen in diesem Namespace zugreifen:

use namespace example1; 
myFunction();

Sie können mehrere Namespaces gleichzeitig öffnen. Nachdem Sie einen Namespace mit use namespace geöffnet haben, bleibt er über den gesamten Codeblock, in dem er geöffnet wurde, offen. Es gibt keine Möglichkeit, einen Namespace explizit zu schließen.

Wenn mehrere Namespaces geöffnet sind, erhöht sich jedoch die Wahrscheinlichkeit von Namenskonflikten. Wenn Sie einen Namespace nicht öffnen möchten, können Sie die Direktive use namespace vermeiden, indem Sie den Methoden- oder Eigenschaftennamen mit dem Namespace und dem Namensqualifizierer qualifizieren. Das folgende Beispiel zeigt, wie der Name myFunction() mit dem Namespace example1 qualifiziert wird:

example1::myFunction();

Verwenden von Namespaces

In der flash.utils.Proxy-Klasse, die einen Teil von ActionScript 3.0 bildet, finden Sie ein realistisches Beispiel eines Namespace, durch dessen Verwendung Namenskonflikte verhindert werden. Die Proxy-Klasse, ein Ersatz für die Object.__resolve-Eigenschaft aus ActionScript 2.0, ermöglicht Ihnen das Abfangen von Verweisen auf nicht definierte Eigenschaften oder Methoden, bevor ein Fehler auftritt. Alle Methoden der Proxy-Klasse befinden sich im flash_proxy-Namespace, um Namenskonflikte zu verhindern.

Um die Einsatzmöglichkeiten des flash_proxy-Namespace besser zu verstehen, müssen Sie wissen, wie die Proxy-Klasse verwendet wird. Die Funktionsmerkmale der Proxy-Klasse stehen nur den Klassen zur Verfügung, die von der Proxy-Klasse erben. Anders ausgedrückt, wenn Sie die Methoden der Proxy-Klasse an einem Objekt anwenden möchten, muss die Klassendefinition des Objekts auf die Proxy-Klasse ausgeweitet werden. Wenn Sie beispielsweise Versuche zum Aufrufen einer nicht definierten Methode abfangen möchten, so müssen Sie die Proxy-Klasse ausweiten und dann die callProperty()-Methode der Proxy-Klasse außer Kraft setzen.

Sie werden sich erinnern, dass das Implementieren von Namespaces im Allgemeinen ein dreistufiger Prozess ist, der sich aus dem Definieren, Anwenden und Referenzieren eines Namespace zusammensetzt. Da Sie jedoch keine der Methoden der Proxy-Klasse explizit aufrufen, wird der flash_proxy-Namespace nur definiert und angewendet, aber nicht referenziert. ActionScript 3.0 definiert den flash_proxy-Namespace und wendet ihn in der Proxy-Klasse an. Ihr Code muss den flash_proxy-Namespace nur auf die Klassen anwenden, welche die Proxy-Klasse erweitern.

Der flash_proxy-Namespace ist etwa wie folgt in dem flash.utils-Paket definiert:

package flash.utils 
{ 
    public namespace flash_proxy; 
}

Der Namespace wird auf die Methoden der Proxy-Klasse angewendet, wie im folgenden Codeausschnitt der Proxy-Klasse dargestellt ist:

public class Proxy 
{ 
    flash_proxy function callProperty(name:*, ... rest):* 
    flash_proxy function deleteProperty(name:*):Boolean 
    ... 
}

Wie der folgende Code veranschaulicht, müssen Sie zunächst sowohl die Proxy-Klasse als auch den flash_proxy-Namespace importieren. Dann deklarieren Sie Ihre Klasse so, dass sie die Proxy-Klasse erweitert (außerdem müssen Sie das Attribut dynamic hinzufügen, wenn Sie im strikten Modus kompilieren). Falls Sie die callProperty()-Methode außer Kraft setzen, müssen Sie den flash_proxy-Namespace verwenden.

package 
{ 
    import flash.utils.Proxy; 
    import flash.utils.flash_proxy; 
 
    dynamic class MyProxy extends Proxy 
    { 
        flash_proxy override function callProperty(name:*, ...rest):* 
        { 
            trace("method call intercepted: " + name); 
        } 
    } 
}

Wenn Sie eine Instanz der MyProxy-Klasse erstellen und eine nicht definierte Methode, wie z. B. die testing()-Methode, aufrufen (siehe folgendes Beispiel), fängt das Proxy-Objekt den Methodenaufruf ab und führt die Anweisungen in der überschriebenen callProperty()-Methode aus (in diesem Fall eine einfache trace()-Anweisung).

var mySample:MyProxy = new MyProxy(); 
mySample.testing(); // method call intercepted: testing

Die Aufnahme der Methoden der Proxy-Klasse in den flash_proxy-Namespace hat zwei Vorteile. Zunächst wird durch einen separaten Namespace die öffentliche Schnittstelle jeder Klasse übersichtlicher, welche die Proxy-Klasse erweitert. (Es gibt etwa ein Dutzend Methoden in der Proxy-Klasse, die Sie außer Kraft setzen können. Keine dieser Methoden wird direkt aufgerufen. Das Platzieren aller dieser Methoden im öffentlichen Namespace könnte verwirrend wirken.) Darüber hinaus werden durch Verwenden des flash_proxy-Namespace Namenskonflikte vermieden, falls Ihre Proxy-Unterklasse Instanzenmethoden mit Namen enthält, die Methoden in der Proxy-Klasse gleichen. Angenommen Sie möchten eine Ihrer eigenen Methoden callProperty() nennen. Der folgende Code wird akzeptiert, da sich Ihre Version der callProperty()-Methode in einem anderen Namespace befindet:

dynamic class MyProxy extends Proxy 
{ 
    public function callProperty() {} 
    flash_proxy override function callProperty(name:*, ...rest):* 
    { 
        trace("method call intercepted: " + name); 
    } 
}

Mit Namespaces kann auch ein Zugriff auf Methoden oder Eigenschaften bereitgestellt werden, der nicht über die vier Zugriffskontrollbezeichner (public, private, internal und protected) möglich ist. Vielleicht haben Sie einige Dienstprogrammmethoden, die über mehrere Pakete verteilt sind. Diese Methoden sollen für alle Pakete zur Verfügung stehen, Sie möchten sie aber nicht als öffentliche Methoden deklarieren. In diesem Fall erstellen Sie einen Namespace und verwenden ihn als Ihren eigenen speziellen Zugriffskontrollbezeichner.

Im folgenden Beispiel werden zwei Funktionen aus unterschiedlichen Paketen in einem benutzerdefinierten Namespace zusammengeführt. Durch Gruppieren dieser Funktionen im gleichen Namespace können Sie beide Funktionen mit nur einer use namespace-Anweisung für eine Klasse oder ein Paket sichtbar machen.

Dieses Beispiel verwendet vier Dateien, um diese Technik zu veranschaulichen. Alle Dateien müssen sich in Ihrem Klassenpfad befinden. Die erste Datei, „myInternal.as“, dient zum Definieren des myInternal-Namespace. Da sich diese Datei in einem Paket namens „example“ befindet, müssen Sie die Datei in einem Ordner mit der Bezeichnung „example“ speichern. Der Namespace wird als public markiert, sodass er in andere Pakete importiert werden kann.

// myInternal.as in folder example 
package example 
{ 
    public namespace myInternal = "http://www.adobe.com/2006/actionscript/examples"; 
}

Mit der zweiten Datei, „Utility.as“, und der dritten Datei, „Helper.as“, werden die Klassen mit den Methoden definiert, die anderen Paketen zur Verfügung stehen sollen. Die Utility-Klasse befindet sich im Paket „example.alpha“. Dies bedeutet, dass die Datei in einem Ordner namens „alpha“ gespeichert werden muss, der wiederum ein Unterordner von „example“ ist. Die Helper-Klasse befindet sich im Paket „example.beta“. Dies bedeutet, dass die Datei in einem Ordner namens „beta“ gespeichert werden muss, der wiederum ein Unterordner von „example“ ist. Beide Pakete, „example.alpha“ und „example.beta“, müssen den Namespace importieren, bevor sie ihn verwenden können.

// Utility.as in the example/alpha folder 
package example.alpha 
{ 
    import example.myInternal; 
     
    public class Utility 
    { 
        private static var _taskCounter:int = 0; 
     
        public static function someTask() 
        { 
            _taskCounter++; 
        } 
         
        myInternal static function get taskCounter():int 
        { 
            return _taskCounter; 
        } 
    } 
} 
 
// Helper.as in the example/beta folder 
package example.beta 
{ 
    import example.myInternal; 
     
    public class Helper 
    { 
        private static var _timeStamp:Date; 
         
        public static function someTask() 
        { 
            _timeStamp = new Date(); 
        } 
         
        myInternal static function get lastCalled():Date 
        { 
            return _timeStamp; 
        } 
    } 
}

Die vierte Datei, „NamespaceUseCase.as“, ist die Hauptanwendungsklasse. Sie muss sich in einem Ordner auf gleicher Ebene wie „example“ befinden. In Flash Professional würde diese Klasse als Dokumentklasse für die FLA-Datei verwendet werden. Die NamespaceUseCase-Klasse importiert auch den myInternal-Namespace und verwendet ihn zum Aufrufen der beiden statischen Methoden, die sich in den anderen Paketen befinden. In diesem Beispiel werden statische Methoden nur zur Vereinfachung des Codes verwendet. Im Namespace myInternal können sowohl statische als auch Instanzmethoden platziert werden.

// NamespaceUseCase.as 
package 
{ 
    import flash.display.MovieClip; 
    import example.myInternal; // import namespace 
    import example.alpha.Utility;// import Utility class 
    import example.beta.Helper;// import Helper class 
     
    public class NamespaceUseCase extends MovieClip 
    { 
        public function NamespaceUseCase() 
        { 
            use namespace myInternal; 
             
            Utility.someTask(); 
            Utility.someTask(); 
            trace(Utility.taskCounter); // 2 
             
            Helper.someTask(); 
            trace(Helper.lastCalled); // [time someTask() was last called] 
        } 
    } 
}