TX 3.1.5: SceneContainerBinReference leak (with proposed fix)

public void Unload()
        {
            Assert.Fatal(_loaded, "TorqueSceneData.Unload - Level not loaded, Load it first.");

            if (!_loaded)
                return;

            _loaded = false;

            // we fire the callback first so that the recipient can unhook itself from content
            if (this.OnUnloaded != null)
                this.OnUnloaded();

            // MR 2/12/11 - Moving before unregister to stop nullrefexception
            // now walk our lists and Unload stuff
            _UnloadObjects(this.SceneData);
            _UnloadObjects(this.Materials);
            _UnloadObjects(this.Objects);

            if (_levelFolder != null && _levelFolder.IsRegistered)
            {
                // unregister the torque folder.  This should unregister everything in it, which will include all objects that were registered
                // since the time the level was created.
                TorqueObjectDatabase.Instance.Unregister(_levelFolder);
                _levelFolder = null; // we null things out for garbage collector
            }


            this.SceneData = null;
            this.Materials = null;
            this.Objects = null;
        }

public abstract class BaseSceneGraph : TorqueObject, IDisposable

#region IDisposable Members

        void IDisposable.Dispose()
        {
            if (Container != null) Container.Dispose();
            base.Dispose();
        }

        #endregion

public void FindObjects(SceneContainerQueryData queryData)
        {
            if (IsDisposed) return; // <== this line gets added
            // Find which bins are covered.
            uint minX, minY, maxX, maxY;

public int GetNumActiveReferences()
        {
            int total = 0;
            int sceneBinArrayCount = _sceneBinArray.GetUpperBound(0) + 1;
            for (int i = 0; i < sceneBinArrayCount; i++) // <== Replace foreach with this
            {
                SceneContainerBinReference walk = _sceneBinArray[i]; // <== Replace binRef with array dereference
                while (walk != null)

public int GetNumObjects()
        {
            Dictionary<ISceneContainerObject, bool> objs = new Dictionary<ISceneContainerObject, bool>();

            int sceneBinArrayCount = _sceneBinArray.GetUpperBound(0) + 1;
            for (int i = 0; i < sceneBinArrayCount; i++) // <== Get rid of foreach loop
            {
                SceneContainerBinReference walk = _sceneBinArray[i]; // <== Change binRef to array dereference
                while (walk != null)

protected internal int _FindObjectsInefficiently(SceneContainerQueryData query)
        {
            int objectsFound = 0;
            _currentSequenceKey++;

            int sceneBinArrayCount = _sceneBinArray.GetUpperBound(0) + 1;
            for (int i = 0; i < sceneBinArrayCount; i++)
                if (_sceneBinArray[i] != null)
                    _FindObjectsInefficientHelper(query, _sceneBinArray[i], ref objectsFound);
            _FindObjectsInefficientHelper(query, _sceneOverflowBin, ref objectsFound);

            return objectsFound;
        }

protected internal void _GetObjects(List<ISceneObject> list)
        {
            _currentSequenceKey++;

            int sceneBinArrayCount = _sceneBinArray.GetUpperBound(0) + 1;
            for (int i = 0; i < sceneBinArrayCount; i++)
                if (_sceneBinArray[i] != null)
                    _GetObjectsHelper(_sceneBinArray[i], list);
            _GetObjectsHelper(_sceneOverflowBin, list);
        }

private int _binIndex = -1;

private struct SceneBinArrayHolder
        {
            public bool IsAllocated;
            public uint BinCount;
            public SceneContainerBinReference[] SceneBin;
        }

        static List<SceneBinArrayHolder> SceneBinArrays = new List<SceneBinArrayHolder>(2);

protected void _CreateBins()
        {
            // Create Scene Bin Array.
            // <== Changes start here
            _binIndex = -1;
            for (int i = 0; i < SceneBinArrays.Count; i++)
            {
                if (!SceneBinArrays[i].IsAllocated && SceneBinArrays[i].BinCount == _binCount)
                {
                    _binIndex = i;
                    break;
                }
            }
            if (_binIndex == -1)
            {
                _binIndex = SceneBinArrays.Count;
                SceneBinArrays.Add(new SceneBinArrayHolder());
            }
            SceneBinArrayHolder hold = SceneBinArrays[_binIndex]; // To work around CS1612
            hold.IsAllocated = true;
            if (hold.SceneBin == null)
            {
                hold.SceneBin = new SceneContainerBinReference[_binCount * _binCount];
                hold.BinCount = _binCount;
            }
            else
            {
                for (int i = 0; i < _binCount * _binCount; i++)
                {
                    hold.SceneBin[i] = null;
                }
            }
            SceneBinArrays[_binIndex] = hold;
            _sceneBinArray = hold.SceneBin; 

            // <== Changes end here
            // if configured to do so, create individual array objects.
            // this can end up creating a lot of objects.
            if (PreAllocSceneBinArrayReferences)
                for (int i = 0; i < _sceneBinArray.Length; ++i)
                    _sceneBinArray[i] = new SceneContainerBinReference();

public override void Dispose()
        {
            _IsDisposed = true;

            for (uint i = 0; i < SceneBinArrays[_binIndex].SceneBin.Length; i++)
            {
                if (SceneBinArrays[_binIndex].SceneBin[i] != null)
                    SceneBinArrays[_binIndex].SceneBin[i].Reset(); // Just to make sure to not create a circular reference of disposed objects
                SceneBinArrays[_binIndex].SceneBin[i] = null;
            }

            _ResetRefs();

            SceneBinArrayHolder hold = SceneBinArrays[_binIndex]; // To work around CS1612
            hold.IsAllocated = false;
            SceneBinArrays[_binIndex] = hold;

            if (_sceneOverflowBin != null)
            {
                _sceneOverflowBin.Reset(); // Just to make sure to not create a circular reference of disposed objects
                _sceneOverflowBin = null;
            }
 
            _sceneBinArray = null;

            if (_sg != null)
            {
                _sg.Reset();
                _sg = null;
            }

        }

_sceneGraph = null;