Delegates in Objekt abspeichern?

[bruce_wayne]

hallo,

tut mir leid wenn es schon einen beitrag zu diesem thema gibt, aber die suche nach "delegate" fördert doch ziemlich viele treffer zu tage.

ich mache es bisher so, dass ich meine delegates in verbindung mit eventListenern immer in klassenvariablen abspeichere, um sie später wieder sauber entfernen zu können. also so:

class Test
{
var btnRollOverDelegate: Object;

public function Test ()
{
btnRollOverDelegate = Delegate.create (this, btnRollOver);
}

irgendwo wird dann

someInstance.addEventListener ("rollOver", btnRollOverDelegate);

aufgerufen, und zum entfernen analog

someInstance.removeEventListener ("rollOver", btnRollOverDelegate);

das ist irgendwie echt umständlich. ich hatte mal gelesen, dass das der sicherste weg wäre, aber ist es wirklich nötig?

[b.asile]

Theoretisch kannst du auch:

PHP-Code:

someInstance.onRollOver = Delegate.create(this, func); 


Aber mir persönlich liegt die Variante die du verwendest am meisten.

[Janoscharlipp]

Bis auf die Typisierung (das Delegate ist ne Function) ist das gut so, wie du es machst.

Ich hab mir auch schonmal Gedanken drüber gemacht, das einzige was mir einfiel war, dass sich die Delegate-Klasse selber um die von ihr erzeugten Delegates kümmern könnte, wenn du beim create noch ne ID übergibst.
Dann könnte die Anwendung so aussehen:

PHP-Code:

// erzeugen
component.addEventListener("event", Delegate.create(this, method, params, "myEventDelegate"));

// löschen
component.removeEventListener("event", Delegate.remove("myEventDelegate")); 


wobei dann die Delegate.remove Methode das Delegate aus einer statischen Map holt, den Eintrag in der Map löscht, und die Delegatefunktion zurückgibt.

[bruce_wayne]

danke für die antworten, das mit der typisierung ist natürlich gut zu wissen.

also belasse ich die delegate-objekte so, und schiele neidisch rüber zu AS3!

@janoscharlipp: hast du so eine erweiterte Delegate-klasse gerade zur hand, oder war das erstmal nur eine überlegung?

[Janoscharlipp]

War eigentlich mehr ne Überlegung, aber hier mal ein Ansatz, als Vorlage diente atotheks Delegate allerdings habe ich einige Änderungen vorgenommen:
* keine Übergabe von Strings für die Methode
* Parameter werden als Array und nicht als weitere Argumente übergeben
* Reihenfolge der Parameter vom Delegate vertauscht

PHP-Code:

class Delegate
{
    private static var delegateMap : Object = new Object();
    
    public static function create(obj:Object, func:Function, params:Array, id:String) : Function
    {
        var delegate : Function = function() {
            return func.apply(obj, params.concat(arguments));
        };
        
        if (id != null) {
            if (delegateMap[id] != null) {
                throw new Error("Delegate#create - there is already a Delegate for id '" + id + "'");
            } else {
                delegateMap[id] = delegate;
            }
        }
        
        return delegate;
    }
    
    public static function remove(id:String) {
        var delegate : Function = delegateMap[id];
        
        if (delegate == null) {
            throw new Error("Delegate#remove - there is no Delegate to remove for id '" + id + "'");
        } else {
            delete delegateMap[id];
            
            return delegate;
        }
    }
} 


Anwendung wäre dann

PHP-Code:

component.addEventListener("myEvent", Delegate.create(this, myMethod, ["myParameter"], "myId"));
// ...
component.removeEventListener("myEvent", Delegate.remove("myId")); 


[hazy fantazy]

Man könnte es eigentlich auch so ähnlich wie AS3 machen, indem man einfach die Funktion eines Objekts durch einem Delegate ersetzt.

PHP-Code:

import mx.utils.Delegate;

class TestDelegates
{
    
    
    private var property : String = "test";
    
    public function TestDelegates( property : String )
    {
        this.property = property;
        
        initDelegates();
    }
    
    public function handleClickButton() : Void
    {
        trace("handleClickButton " + property);
    }
    
    private function initDelegates() : Void
    {
        handleClickButton = Delegate.create( this, handleClickButton );
    }

} 


Wenn du die handleClickButton jetzt als Listener benutzt, ist es automatisch ein Delegate.

PHP-Code:

btn1.addEventListener( "click", new TestDelegates("eins").handleClickButton);
btn2.addEventListener( "click", new TestDelegates("zwei").handleClickButton); 


mfg
hz

[bruce_wayne]

@janoscharlipp: super, vielen dank! werde das gleich mal ausprobieren.

@hazy: danke, guter denkanstoss. wie würde dann entfernen des events aussehen, bzw. würde das hier funktionieren?

PHP-Code:

btn1.removeEventListener( "click", new TestDelegates("eins").handleClickButton); 


[sebastian]

Ich speichere übrigens auch in Variablen. Das Problem ist halt, dass bei
Delegate jedes Mal eine neu generierte Funktion zurückgeliefert wird und
diese natürlich nicht zugeordnert werden könnne.

Und das mit der ID finde ich weniger schön, deshalb bleibe ich bei meiner Variante

gruß

[hazy fantazy]

Die Instanz von TestDelegates musst du dann schon irgendwo speichern.
Und dann einfach btn.removeListener("click", testDelegate.handleClickButton )

Man spart sich auf jeden Fall die zusätzlichen Variablen für jeden Delegate.

[Janoscharlipp]

Ich glaube bei hazy fantazy würde das etwas anders aussehen.
Eher so, dass du deine Klasse hast, welche die Event-Methoden enthält, und die diese am Anfang durch die Delegates ersetzt. Dann kannst du diese Methoden einfach ganz normal verwenden, also

PHP-Code:

// ganz am Anfang
myEventMethod = Delegate.create(this, myEventMethod);

// irgendwann
component.addEventListener("myEvent", myEventMethod);
// ... later
component.removeEventListener("myEvent", myEventMethod); 


EDIT: ups, zu spät

[sebastian]

Zitat von Janoscharlipp

Ich glaube bei hazy fantazy würde das etwas anders aussehen.
Eher so, dass du deine Klasse hast, welche die Event-Methoden enthält, und die diese am Anfang durch die Delegates ersetzt. Dann kannst du diese Methoden einfach ganz normal verwenden, also

PHP-Code:

// ganz am Anfang
myEventMethod = Delegate.create(this, myEventMethod);

// irgendwann
component.addEventListener("myEvent", myEventMethod);
// ... later
component.removeEventListener("myEvent", myEventMethod); 


EDIT: ups, zu spät

Das ist doch die normale Variante von der Ausgangssituation?

[hazy fantazy]

Der Unterschied ist, dass eine Funktion durch ihren Delegate ersetzt wird.

PHP-Code:

wichtigeFunktion = createDelegate( this, wichtigeFunktion ); 


Du brauchst dann keine extra Variable mehr für den Delegate
und die Nutzerklasse kann einfach die Eigenschaft selbst als
Listener benutzen und muss nicht mehr Delegate.create benutzen.

[Janoscharlipp]

Nö, hier nochmal als Klasse, da wird es klarer:

PHP-Code:

import mx.controls.Button;
import mx.utils.Delegate;

class MyClass extends MovieClip {
    private var myButton : Button;
    
    public function MyClass()
    {
        initializeDelegates();
        
        setListeners();
    }
    
    private function initializeDelegates() : Void
    {
        myEventFunction = Delegate.create(this, myEventFunction);
    }
    
    private function setListeners() : Void
    {
        myButton.addEventListener("click", myEventFunction);
    }
    
    public function myEventFunction(event:Object) : Void
    {
        trace("CLICK - this: " + this); // ergibt Instanz von MyClass
        
        myButton.removeEventListener(myEventFunction);
    }
} 


EDIT: schon wieder zu langsam, das wir hoffentlich nicht zur Gewohnheit

[sebastian]

Ah stimmt, das ist echt eine gute Variante, auch wenn sie sicher nicht 100%ig sauber ist.

Meint ihr man sollte immer so vorgehen? Von der Anwendung ist es am Ende
ja eindeutig die schönere Variante.

[hazy fantazy]

So richtige Nachteile kann ich auch nicht entdecken. Schön ist, dass sich die Klasse selbst versaut und nicht jemand anders