this-Referenz in anonymen Methoden

[Szdnez]

Hallo,

gibt es eine elegante Variante auf die this-Referenz in einer anonymen Methode zuzugreifen? Zum Beispiel:

public interface MyInterface
{
    ...
} 

public final class MyCheckBox
extends CheckBox
implements MyInterface
{
    public function MyCheckBox()
    {
        super();
    }
 
    public function registerFunction( pFunction:Function ) : void
    {
        addEventListener( Event.CHANGE, function( pEvent:Event = null ) : void
            {
                if ( pFunction != null )
                {
                    pFunction( this as MyInterface );
                }
            } );
    }
} 

In Zeile 15 wird so immer null übergeben, weil this nicht die Checkbox ist, sondern global. Oder bleibt in diesem Fall nur pEvent.target as MyInterface?

[Omega Psi]

Anonyme Funktionen sind nicht im namespace der Klasse registriert, sondern im anonymen namespace. Das heisst, die Funktion kennt ihre Umgebung - die Klasse - nicht. Das Binding der Funktion an die Klasse wird durch ein Closure implementiert. So kann die Funktion überhaupt erst von dem Dispatcher als "eigene" Methode verwendet werden.

Dein Problem ist, dass der Scope der Funktion nicht, wie augenscheinlich, die Funktion in der sie definiert wurde ist, sondern wie gesagt anonym ist. Ein bessere Implementierung wäre:

package
{
    import flash.events.Event;
 
    import mx.controls.CheckBox;
 
    public class SuperCheckBox extends CheckBox
    {
 
        private var _newFunction:Function;
 
        public function get newFunction():Function
        {
            return _newFunction;
        }
 
        public function set newFunction(value:Function):void
        {
            _newFunction = value;
        }
 
        public function SuperCheckBox()
        {
            super();
 
            addEventListener(Event.CHANGE, function(event:Event):void
            {
               var checkBox:SuperCheckBox = SuperCheckBox(event.target);
               if (checkBox.newFunction != null)
               {
                   checkBox.newFunction(checkBox);
               }
            });
        }
    }
} 

Wobei ich eher mich frage, wieso du nicht einfach den Eventhandler dort implementierst, wo es passieren soll?

package
{
 
    import flash.events.Event;
 
    import mx.controls.CheckBox;
 
    public class CheckBoxStrategy {
 
        private var _checkBox:CheckBox;
 
        public function get checkBox():CheckBox
        {
            return _checkBox;
        }
 
        public function set checkBox(value:CheckBox):void
        {
            if (_checkBox)
            {
                _checkBox.removeEventListener(Event.CHANGE, checkBox_changeHandler)
            }
 
            _checkBox = value;
 
            if (_checkBox)
            {
                _checkBox.addEventListener(Event.CHANGE, checkBox_changeHandler);
            }
        }
 
        private function checkBox_changeHandler(event:Event):void
        {
            var checkBox:CheckBox = CheckBox(event.target);
 
            handleCheckBoxChangeEvent(checkBox);
        }
 
        private function handleCheckBoxChangeEvent(checkBox:CheckBox):void
        {
            /*
             * Some magic...
             */
        }
    }
} 

und die ungarische Notation ist so 80er

[Szdnez]

Danke, aber einen großen Unterschied zwischen deinem ersten Vorschlag und meiner Implementierung ist für mich nicht ersichtlich. Ich registriere gleich die Funktion beim EventHandler und du merkst sie dir noch vor.
Zu meinem Beispiel sei vielleicht angemerkt, spielt auch für deine zweite Variante eine Rolle, dass das ganze in einem größeren Kontext statt findet. Im Prinzip gibt es schon eine Strategy-Klasse, allerdings weiß diese nicht, um was für ein Kind (in diesem Fall eine Checkbox) es sich genau handelt. Die registerFunction() hat die Bedeutung, dass sich irgendeine Funktion (also irgend jemand) dafür interessiert, wann sich an dem Kind etwas ändert. Und je nachdem, um was für ein konkretes Kind es sich handelt, können die auslösenden Ereignisse ganz andere sein. Und über die anonyme Methode wollte ich einfach ein paar Properties usw. sparen, da die Klassen meist eh schon sehr voll sind und diese Informationen auch sonst an keiner anderen Stelle benötigt werden.

Was die ungarische Notation betrifft:

1. Ich bin 80er Jahrgang
2. Bei uns ist es Standard
3. Ob ich jetzt _ schreibe oder v, was in "meiner" Welt das äquivalent dazu ist, macht keinen großen Unterschied. Außer das ich dann zusätzlich noch zwischen Parametern, statischen Attributen usw. unterscheiden kann.
4. Zudem finde ich es schön
5. Und früher war sowieso alles besser

Immerhin sind meine Code-Beispiele schon in englisch (im Gegensatz zu meinem eigentlichen Code)

[Omega Psi]

Zitat von Szdnez

Danke, aber einen großen Unterschied zwischen deinem ersten Vorschlag und meiner Implementierung ist für mich nicht ersichtlich. Ich registriere gleich die Funktion beim EventHandler und du merkst sie dir noch vor.

Das ist ein großer Unterschied, da ich unabhängig vom Scope mit der Closure arbeiten kann, während deine Variante nicht funktioniert...

Zitat von Szdnez

Immerhin sind meine Code-Beispiele schon in englisch (im Gegensatz zu meinem eigentlichen Code)

You heathen!!!

Und noch eine Variante, die ich wählen würde, müsste ich mit einer Closure arbeiten:

package
{
    import flash.events.Event;
 
    import mx.controls.CheckBox;
 
    public class SuperCheckBox extends CheckBox
    {
 
        private var _newFunction:Function;
 
        public function get newFunction():Function
        {
            return _newFunction;
        }
 
        public function set newFunction(value:Function):void
        {
            _newFunction = value;
        }
 
        public function SuperCheckBox()
        {
            super();
 
            addEventListener(Event.CHANGE, changeHandler);
        }
 
        public function changeHandler(event:Event):void
        {
           if (newFunction != null)
           {
               newFunction(this);
           }
        }
    }
}