The 2nd test is more correct, but it stores a reference to WeakMethodClosure in the main object rather than in TestObject. This creates an outside reference and stops TestObject and WeakMethodClosure from getting Gced. For this to work the ‘closure’ instance variable has to be moved to TestObject. But there’s another reference via the Timer event listener, which isn’t weak in the test so that will also prevent garbage collection. That listener has to be weak for it to not count as a reference into the circuit.

One other thing is this has to be tested inside the profiler and not in the debugger if you guys are using FlexBuilder. Because the debugger has somekind of a bug that prevents garbage collector from running as opposed to the profiler.

The problem with creating a utility like WeakMethodClosure is forming that reference from the user to it. WeakMethodClosure can’t do this automatically without placing some really heavy restrictions on the user. Like requiring it to be dynamic, or subclass of EventDispatcher (so that it can add a dummy event listener to itself), or an interface which requires the hassle of implementing a way to store WeakMethodClosure in the user. One more or less sensible way to implement this utility is adding a 3rd object to store WeakMethodClosure. So that the user has to explicitly define a variable and assign an instance of this manager to it and then instead of doing new WeakMethodClosure( myMethod ), it would do weakMethods.createClosure( myMethod ). Note that the user, manager, and WeakMethodClosure form a circuit so it’s fine. It’s an ugly interface but it works and there’s considerably less magic in it than in other ways of attempting to do this.

http://www.gskinner.com/blog/archives/2006/07/as3_dictionary.html

I am trying to create a better solution for creating weak references to a method. But I guess it’s not possible.

For some reasons it’s not possible to use a method as a key in a Dictionary with weak-keys (they are deleted immediatly, even when the method still exists), so maybe it’s a bug.

Useless is a bit harsh for my poor class ;) It’s just useless as soon as you use an instance function. Though you’re right: it *usually* is totally useless :)

For what you want (and what I probably want too) we just have to make the closure a little bit weaker:

package com.betabong.util
{
	import flash.utils.Dictionary;
 
	public class WeakerMethodClosure
	{
		private var holder : Dictionary;
 
		function WeakerMethodClosure( target : Object , method : Function , arguments : Array = null ) : void {
			var fholder : Dictionary = new Dictionary( true );
			fholder[ method ] = arguments;
			holder = new Dictionary( true );
			holder[ target ] = 	fholder;
		}
 
		public function call() : Boolean {
			var args : Array;
			var f : Function;
			var cache : Dictionary;
			for ( var obj : * in holder ) {
				cache = holder[obj] as Dictionary;
				for ( var fnc : * in cache ) {
					f = fnc as Function;
					args = cache[ fnc ] as Array;
					f.apply( obj , args );
					return true;
				}
			}
			return false;
		}
	}
}

testing with:

package {
	import com.betabong.util.WeakerMethodClosure;
 
	import flash.display.Sprite;
	import flash.events.TimerEvent;
	import flash.utils.Timer;
 
	import test.TestTrace;
 
	public class ActionscriptTests extends Sprite
	{
		private var holder : WeakerMethodClosure;
 
		public function ActionscriptTests()
		{
			init();
		}
 
		public function init() : void {
			var o:TestTrace = new TestTrace();
			holder = new WeakerMethodClosure( o , o.test );
 
			// let's call it once to make sure it works
			holder.call();
 
			var timer : Timer = new Timer( 1000 , 10 );
			timer.addEventListener(TimerEvent.TIMER , call );
			timer.start();
		}
 
		public function call( e:* ) : void {
			trace( "Calling holder" );
			holder.call();
		}
	}
}

and:

package test
{
	public class TestTrace
	{
		static public var globalindex : uint = 0;
		private var localindex : uint = 0;
		private var callcounter : uint = 0;
 
		public function TestTrace()
		{
			localindex = ++globalindex;
			trace( toString() + " created" );
		}
 
		public function test() : void {
			trace( toString() + " called " + (++callcounter) + " times" );
		}
 
		public function toString() : String {
			return "TestTrace " + localindex;
		}
 
 
	}
}

outputs:

TestTrace 1 created
TestTrace 1 called 1 times
Calling holder
Calling holder
Calling holder
Calling holder

Is this more useful? Probably. A very little bit. Under normal situations we hopefully don’t have to use such weird constructs.

– Store the object inside the MethodStorage
– use the MethodStorage as key
– use a dummy value (like true, or a timestamp) as value

Try this example:

package  
{
	import com.betabong.util.WeakMethodClosure;
 
	import flash.display.Sprite;
	import flash.events.TimerEvent;
	import flash.utils.Timer;	
 
	public class NotificationCenterExample extends Sprite 
	{
		private var closure : WeakMethodClosure;
		private var timer : Timer;
 
		public function NotificationCenterExample()
		{			
			testWeakClosure();
		}
 
		public function testWeakClosure() : void {
			var tempObject:TestObject = new TestObject();
			closure = new WeakMethodClosure( tempObject , tempObject.test );
			callWeakClosure();
 
			timer = new Timer( 50 );
			timer.addEventListener(TimerEvent.TIMER , callWeakClosure );
			timer.start();
		}
 
		public function callWeakClosure( event : TimerEvent = null ) : void {
			if ( !closure.call() ) {
				trace( "Closure failed" );
			}
		}
	}
}
 
class TestObject
{
	public function test():void
	{
		trace("Called test");
	}
}

Outputs:

Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test
Called test

So I guess your class is useless

Its main purpose is though to avoid accidental memory leaks, and for this it has it’s uses. There is btw a class flash.events.WeakMethodClosure that’s used internally – I’m not sure what it does exactly though (no code available..).

You certainly have more knowledge of the garbage collection process, so if you can shed more light on this, it would be cool. I’d also love to hear from the Flash Player team what exactly is going on with those weak references, so we’re not so much moving in the dark.

I’m not saying code code doesn’t work period, I may in fact be wrong. But from looking at it I’m seeing a flaw in it. I’d be interested in seeing the test code you have for this and trying it out.

Reassuring to know that other people are having similar memory hurdles. Cheers!