with regards to your code, what about the scenario i have described below, where there are 2 class listeners, which execute functions, however only the one function is supposed to remove both the eventListeners, how will your class handle this? because the way i see it, you have a delegate function parameter passed into the function being called, but now if there are 2 eventListeners to remove what happens there? i sort of tried to do it this method with your code, am not getting it right, and not sure if any of my event listeners are being deleted…

class Apple{ public function Apple() { this.addEventListener("blue", Delegate.create(this, funcA); this.addEventListener("red", Delegate.create(this, funcB); }

 public function funcA(event:Object) {
        //do somehing
 }

public function funcB(event:Object) { this.removeEventListener("blue", Delegate.create(this, funcA); this.removeEventListener("red", Delegate.create(this, funcB);
}

}

thanks clarklin

the first line of this function is added var fProxy:Function = function():Void { aParameters[aParameters.length] = fProxy; var aActualParameters:Array = arguments.concat(aParameters); fFunction.apply(oTarget, aActualParameters); };

class com.ascb.util.Proxy {

public static function create(oTarget:Object, fFunction:Function):Function {

var aParameters:Array = new Array();
for(var i:Number = 2; i 

I feel like if you add the reference to the arguments you are essentially polluting the function with extra information. At first glance this doesn’t seem very safe in those instances when you prefer to omit or null argument values.

My personal jgDelegate class was first expanded from the work at createage.com. Since then it has grown to include create, proxy, returns, overwriting, as well as static & dynamic appending. I recently added to the post to include a version after reading this blog post and another.

If you are interested, check it out over at http://www.justgooddesign.com/blog/jgdelegate.htm

The memory leaks mentioned in this article and in the comments are made apparent when many Delegates are created. In the earlier version of this class the Delegate function would retain a reference to itself through the activation object at the top of the scope chain, and because there was a reference to it the delegate would never be garbage collected. This was fixed in version 1.0.1.

Very interesting article because it hits right on an area I’m concerned about in my application. Perhaps you might be able to help me and others with a similar problem with your obvious expertise.

Say I have a video player (FLVPlayback) and a button that loads videos into it from a list of videos using the following function:

public function playVideo(vid:String):Void{     

    my_FLVPlayback.contentPath = vid;
    my_FLVPlayback.addEventListener("complete", Delegate.create(this, onVidComplete));

}

Do I need to remove the previous event listener each time the button is hit and a new video is loaded? If I don’t will there be “memory leak” or an accumulation of listeners on my_FLVPlayback?

Seems if this is the case, your class will be a big help. Thanks, Micahael

It basically removes the circular reference from the activation object in the anonymous function and the anonymous function itself by making sure that the anonymous function doesn’t actually make use of the activation object. Instead the necessary variables are attached to the Function object so it can reference then directly with arguments.callee.