Author Topic: Kean Walmsley on Dispose() (Read 8439 times)

TheMaster · « **on:** August 23, 2012, 09:15:56 AM »

Well, I think we knew this was coming

Kean points out that the MSDN docs here say that it is not recommended to use using() with a variable whose scope exceeds the scope of the using() block, but what he doesn't mention is that when you have a foreach() block enclosing nothing but a using() block (or visa-verse), they both have the same effective scope, and in fact, you can enforce that by using only a single set of curly braces:

In other words, this:

Code - C#: [Select]

  using (var brep = new Brep(path))
  {
    foreach (var face in brep.Faces)
    {
      using (var surf = face.Surface)
      {
           // code here omitted for brevity 
      }
      face.Dispose();
    }
  }
 

is functionally equivalent to this:

Code - C#: [Select]

   using (var brep = new Brep(path))
   foreach (var face in brep.Faces)
   using( face )
   using (var surf = face.Surface)
   {
       // same code omitted above, omitted here as well 
   }
 

Notice there's only one pair of curly braces that act as the scope delimiters of everything passed to the using() and foreach() statements preceding the open curly brace, and that serves to eliminate any room for error, namely the one given in the example in the referenced MSDN docs, where the code erroneously uses a variable passed to using() after it's been disposed.

So, take that recommendation in the MSDN docs with a grain of salt, and by just using a bit of common sense it should be clear that it's not necessarily applicable in every situation.

I was going to post this in the comments on Kean's blog but you can't post comments with formatted code there.

TheMaster · « **Reply #1 on:** August 23, 2012, 09:45:31 AM »

One more thing that Kean mentions is AutoCAD crashing at shutdown because the destructor of a C++ object that was left on the heap executed too late in the shutdown process, or on a non-AutoCAD thread, and that's a legitimate reason why a managed wrapper for a native C++ object with a badly-designed destructor needs to be disposed.

One of the problems I've always had with 'overly-aggressive' use of Dispose() is that it results in code that's greatly more complex and difficult to follow. So, what I do is use my abstract ExtensionApplication class that I posted a watered-down version of here to manage IDisposables that need to be Disposed before AutoCAD terminates.

Code - C#: [Select]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Autodesk.AutoCAD.ApplicationServices;
 
namespace Autodesk.AutoCAD.Runtime
{
   public abstract class ExtensionApplication : IExtensionApplication
   {
      void IExtensionApplication.Initialize()
      {
         try
         {
            this.Initialize();
         }
         catch( System.Exception ex )
         {
            Console.Beep();
            WriteMessage( "\nAn error occured while loading {0}:\n\n{1}",
              this.GetType().Assembly.Location,
              ex.ToString()
            );
            throw ex;
         }
      }
 
      static void WriteMessage( string fmt, params object[] args )
      {
         Document doc = ApplicationServices.Application.DocumentManager.MdiActiveDocument;
         if( doc != null )
            doc.Editor.WriteMessage( fmt, args );
      }
 
      // Derived types must override this to do initialization
      // and do not need to worry about catching exceptions:
 
      protected abstract void Initialize();
 
      // Derived types can optionally override this to do finalization:
      protected virtual void Terminate()
      {
      }
 
      void IExtensionApplication.Terminate()
      {
         try
         {
            this.Terminate();
            if( Terminating != null )
               Terminating( this, EventArgs.Empty );
         }
         finally
         {
            Terminating = null;
            if( disposables != null )
            {
               disposables.Dispose();
               disposables = null;
            }
         }
      }
 
      // This event can be handled as an alternative way
      // of doing termination handling:
 
      public static event EventHandler Terminating = null;
 
      static DisposableList<IDisposable> disposables = new DisposableList<IDisposable>();
 
      // Pass this method any IDisposable and it will be disposed before
      // AutoCAD shuts down, when the Terminate() method is called.
 
      public static void AddDisposable( IDisposable disposable )
      {
         if( disposables != null )
            disposables.Add( disposable );
      }
 
      public static bool RemoveDisposable( IDisposable disposable )
      {
         if( disposables != null )
            return disposables.Remove( disposable );
         else
            return false;
      }
 
      public static bool ContainsDisposable( IDisposable disposable )
      {
         if( disposables != null )
            return disposables.Contains( disposable );
         else 
            return false;
      }
 
   }
}
 
// DisposableList.cs
 
namespace System.Collections.Generic
{
   public class DisposableList<T> : List<T>, IDisposable
      where T : IDisposable
   {
      bool disposed = false;
 
      /// <summary>
      /// If true, contained items are disposed of in reverse order
      /// (last to first). 
      /// 
      /// Default value: false
      /// </summary>
 
      bool ReverseOrderedDispose
      {
         get;
         set;
      }
 
      public DisposableList()
      {
      }
 
      public DisposableList( int capacity )
         : base( capacity )
      {
      }
 
      public DisposableList( IEnumerable<T> collection )
         : base( collection )
      {
      }
 
      public DisposableList( System.Collections.IEnumerable collection )
         : base( collection.Cast<T>() )
      {
      }
 
      public void Dispose()
      {
         Dispose( true );
      }
 
      protected virtual void Dispose( bool disposing )
      {
         bool flag = this.disposed;
         this.disposed = true;
         if( disposing && !flag )
         {
            if( this.ReverseOrderedDispose )
               base.Reverse();
            using( IEnumerator<T> e = base.GetEnumerator() )
               DisposeItems( e );
         }
      }
 
      private void DisposeItems( IEnumerator<T> e )
      {
         while( e.MoveNext() )
         {
            try
            {
               T item = e.Current;
               if( item != null )
                  item.Dispose();
            }
            catch
            {
               DisposeItems( e );
               throw;
            }
         }
      }
   }
 
}
 
// Example use:
 
[assembly: ExtensionApplication( typeof( MyApplication ) )]
 
public class MyApplication : ExtensionApplication
{
  protected override void Initialize()
  {
    // Do initialization here
 
    // Create an object that implements IDisposable and
    // let ExtensionApplication manage it:
    ExtensionApplication.AddDisposable( myDisposable );
 
  }
}
 
 

TheMaster · « **Reply #2 on:** August 23, 2012, 09:54:13 AM »

And one more thing....

Quote from: kean

One thing that’s a little peculiar with the Brep API is that you’re actually forcing a Dispose() on objects that are properties of the Brep object itself (objects that are instantiated when you access the property). That doesn’t always seem right – you would expect the using block around the Brep object to force a Dispose() on all associated objects created/exposed via its properties – but this a quirk of the Brep API that needs special attention, and a big reason the GC-driven finalisation of unmanaged objects seems to rear its ugly head more often when it’s used.

The fact that many 'owned' objects implement IDisposable is coincidental to their deriving from DisposableWrapper, and RXObject.

Kean says nothing about the AutoDelete property, which is false if the native object should not be deleted when its managed wrapper is Disposed, and that's usually the case with managed wrappers for aggregate objects that are owned by some other native object, which is responsible for managing their lifetime and deleting them.

As I think I mentioned previously, if you're not sure about the need to dispose something, just check its AutoDelete property. If it's false, then the odds are that you are either not supposed to dispose it, or don't need to.

Keith™ · « **Reply #3 on:** August 23, 2012, 10:08:08 AM »

Quote from: TT on August 23, 2012, 09:54:13 AM

if you're not sure about the need to dispose something, just check its AutoDelete property. If it's false, then the odds are that you are either not supposed to delete it, or don't need to.

Does that mean this would be acceptable in all cases where you are deleting an object?

Code - C#: [Select]

if ( MyObject.AutoDelete )
{
     MyObject.Delete();
}

I have never understood the AutoDelete property and your description makes it seem counter-intuitive i.e. if AutoDelete is false it is automatically handled? It seems it should be the other way around unless I am missing something.

TheMaster · « **Reply #4 on:** August 23, 2012, 10:19:30 AM »

This was a comment I just posted on Kean's blog, regarding his analysis on this subject.

Quote

Kean, this is more directed at Fenton's advice regarding Dispose(), but neither his nor any of your posts on this topic so much as graze one important aspect of the question, which is the DisposableWrapper's AutoDelete property.

If this property is false, the wrapped native object is not deleted when its managed wrapper is disposed, and disposing a managed wrapper whose AutoDelete property is false, is both pointless and a source of code obfuscation.

And, if one is going to check the value of this property and use it as a guide for deciding to Dispose the managed wrapper, then one must remember that the managed wrapper can change its value depending on certain conditions. For example, the Database managed wrapper sets this property to true only when the wrapped AcDbDabase was created via a call to ReadDwgFile(). For databases that are open in the drawing editor, the value of AutoDelete is false.

I think it's a bit silly for everyone to be debating this issue when the value of that property literally and definitively answers that question for many (but not all) objects, don't you agree?

If we're going to debate the question of 'To Dispose or not to Dispose', it might help if everyone including the audience, become a bit more familiar with the inner workings of DisposableWrapper, and the fact that any managed wrapper that represents a native object that derives from AcRxObject, must derive from DisposableWrapper, regardless of whether it must be disposed or not.

TheMaster · « **Reply #5 on:** August 23, 2012, 10:23:48 AM »

Quote from: Keith™ on August 23, 2012, 10:08:08 AM

Quote from: TT on August 23, 2012, 09:54:13 AM
if you're not sure about the need to dispose something, just check its AutoDelete property. If it's false, then the odds are that you are either not supposed to delete it, or don't need to.

Does that mean this would be acceptable in all cases where you are deleting an object?
Code - C#: [Select]
if ( MyObject.AutoDelete )
{
MyObject.Delete();
}

I have never understood the AutoDelete property and your description makes it seem counter-intuitive i.e. if AutoDelete is false it is automatically handled? It seems it should be the other way around unless I am missing something.

Some native objects should never be deleted when their managed wrapper is disposed, so this property tells the base class if it needs to delete the managed wrapper automatically. For example, if you call Dispose() on a Database wrapper for a database that's open in the editor, and the underlying AcDbDatabase was deleted, the result would be catastrophic, so this property is intended to ensure that could not happen.

Keith™ · « **Reply #6 on:** August 23, 2012, 10:33:47 AM »

So, am I to understand that the AutoDelete property is really in reference to the underlying unmanaged object? i.e. if AutoDelete is false, the unmanaged object doesn't get deleted when the wrapper is disposed. This makes sense in that the unmanaged object is not automatically deleted when its wrapper is disposed.

However, doesn't that mean that the unmanaged object should be deleted? Will it result in memory leaks if it is not?

Jeff H · « **Reply #7 on:** August 23, 2012, 11:20:58 AM »

For a DBObject it checks Autodelete and pointer and if so calls DeleteUmanagedObject

Code - C#: [Select]

 
        ////    DisposableWrapper
        public sealed override void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }
 
        ////    DisposableWrapper
        protected virtual void Dispose([MarshalAs(UnmanagedType.U1)] bool flag)
        {
            if (flag)
            {
                this.~DisposableWrapper();
            }
            else
            {
                try
                {
                    this.!DisposableWrapper();
                }
                finally
                {
                    base.Finalize();
                }
            }
        }
        ////    DisposableWrapper
        private void ~DisposableWrapper()
        {
            this.!DisposableWrapper();
        }
        ////    DisposableWrapper
        private void !DisposableWrapper()
        {
            if (this.m_bAutoDelete && this.m_imp != IntPtr.Zero)
            {
                this.DeleteUnmanagedObject();
            }
            this.Detach();
        }
 
 
 
        ////    DisposableWrapper
        internal void Detach()
        {
            this.m_imp = IntPtr.Zero;
            if (this.m_bAutoDelete)
            {
                GC.SuppressFinalize(this);
            }
            this.m_bAutoDelete = false;
            GC.KeepAlive(this);
        }
 
        ////    DBObject
        protected override void Dispose([MarshalAs(UnmanagedType.U1)] bool flag)
        {
            if (flag)
            {
                try
                {
                    return;
                }
                finally
                {
                    base.Dispose(true);
                }
            }
            try
            {
                this.!DBObject();
            }
            finally
            {
                base.Dispose(false);
            }
        }
        ////    DBObject
        protected unsafe override void DeleteUnmanagedObject()
        {
            AcDbObject* impObj = this.GetImpObj();
            AcDbObjectId acDbObjectId;
            if (((*<Module>.AcDbObject.objectId(impObj, &acDbObjectId) == 0L) ? 1 : 0) != 0)
            {
                if (impObj != null)
                {
                    object arg_24_0 = calli(System.Void* modopt(System.Runtime.CompilerServices.CallConvCdecl)(System.IntPtr,System.UInt32), impObj, 1, *(*(long*)impObj));
                }
            }
            else
            {
                int num = (int)<Module>.AcDbObject.close(this.GetImpObj());
                if (num != 0)
                {
                    throw new Autodesk.AutoCAD.Runtime.Exception((ErrorStatus)num);
                }
            }
        }
        ////    DBObject
        public void Close()
        {
            int num = (int)<Module>.AcDbObject.close(this.GetImpObj());
            if (num != 0)
            {
                throw new Autodesk.AutoCAD.Runtime.Exception((ErrorStatus)num);
            }
            base.Detach();
        }
 

Kean · « **Reply #8 on:** August 23, 2012, 12:35:01 PM »

Quote from: TT on August 23, 2012, 10:19:30 AM

This was a comment I just posted on Kean's blog, regarding his analysis on this subject.

Quote

Kean, this is more directed at Fenton's advice regarding Dispose(), but neither his nor any of your posts on this topic so much as graze one important aspect of the question, which is the DisposableWrapper's AutoDelete property.

If this property is false, the wrapped native object is not deleted when its managed wrapper is disposed, and disposing a managed wrapper whose AutoDelete property is false, is both pointless and a source of code obfuscation.

And, if one is going to check the value of this property and use it as a guide for deciding to Dispose the managed wrapper, then one must remember that the managed wrapper can change its value depending on certain conditions. For example, the Database managed wrapper sets this property to true only when the wrapped AcDbDabase was created via a call to ReadDwgFile(). For databases that are open in the drawing editor, the value of AutoDelete is false.

I think it's a bit silly for everyone to be debating this issue when the value of that property literally and definitively answers that question for many (but not all) objects, don't you agree?

If we're going to debate the question of 'To Dispose or not to Dispose', it might help if everyone including the audience, become a bit more familiar with the inner workings of DisposableWrapper, and the fact that any managed wrapper that represents a native object that derives from AcRxObject, must derive from DisposableWrapper, regardless of whether it must be disposed or not.

Strange - I didn't get that comment through.

Keith™ · « **Reply #9 on:** August 23, 2012, 04:34:21 PM »

... and I am still as confused as I was before ...

AutoDelete = false means the underlying item isn't deleted when the wrapper is disposed, but disposing when AutoDelete = false is unnecessary and disposing when AutoDelete is true means the underlying object is disposed when the wrapper is disposed so disposing the wrapper automatically deletes the underlying unmanaged object.

which brings me full circle to what the heck does it mean? Dispose or not? ... and how can we effectively use AutoDelete to determine if we should dispose of the managed wrapper?

TheMaster · « **Reply #10 on:** August 23, 2012, 05:51:41 PM »

Quote from: Keith™ on August 23, 2012, 10:33:47 AM

So, am I to understand that the AutoDelete property is really in reference to the underlying unmanaged object? i.e. if AutoDelete is false, the unmanaged object doesn't get deleted when the wrapper is disposed. This makes sense in that the unmanaged object is not automatically deleted when its wrapper is disposed.

However, doesn't that mean that the unmanaged object should be deleted? Will it result in memory leaks if it is not?

Some native objects are part of an aggregation, which are usually exposed and managed by some other native 'owner' object. For example, the TransactionManager is a wrapper for an AcDbTransctionManager. The native AcDbTrasactionManager object is created and deleted by the native AcDbDatabase that uses it, so it should never be deleted by anyone else, including managed wrappers. If you check, you should see that a TransactionManager's AutoDelete property is false, making disposal pointless.

I wasn't suggesting that one should write code that checks the AutoDelete property at runtime and disposes the object only if it's true because that results in even greater code obfuscation than just calling Dispose(). I was suggesting that one can check to see if the type(s) of managed wrappers their code works with always have their AutoDelete property set to false. If so, then it is probably better to not bother disposing them.

Keith™ · « **Reply #11 on:** August 23, 2012, 08:01:34 PM »

That makes more sense ... now the problem becomes understanding which of these items should be disposed always and which should be disposed occasionally and which should never be disposed.

Maybe I should have went into medicine .. at least then my clients would understand that everything I do is practice ...

Kerry · « **Reply #12 on:** August 23, 2012, 10:02:52 PM »

Quote from: TT on August 23, 2012, 10:19:30 AM

This was a comment I just posted on Kean's blog, regarding his analysis on this subject.

Quote

< .. >

If we're going to debate the question of 'To Dispose or not to Dispose', it might help if everyone including the audience, become a bit more familiar with the inner workings of DisposableWrapper, and the fact that any managed wrapper that represents a native object that derives from AcRxObject, must derive from DisposableWrapper, regardless of whether it must be disposed or not.

Tony,
[for clarity]
I assume the 'must' should be read as 'does'

Regards
Kerry

TheMaster · « **Reply #13 on:** August 23, 2012, 10:03:39 PM »

Quote from: Kean on August 23, 2012, 12:35:01 PM

Quote from: TT on August 23, 2012, 10:19:30 AM

This was a comment I just posted on Kean's blog, regarding his analysis on this subject.

Quote

Kean, this is more directed at Fenton's advice regarding Dispose(), but neither his nor any of your posts on this topic so much as graze one important aspect of the question, which is the DisposableWrapper's AutoDelete property.

If this property is false, the wrapped native object is not deleted when its managed wrapper is disposed, and disposing a managed wrapper whose AutoDelete property is false, is both pointless and a source of code obfuscation.

And, if one is going to check the value of this property and use it as a guide for deciding to Dispose the managed wrapper, then one must remember that the managed wrapper can change its value depending on certain conditions. For example, the Database managed wrapper sets this property to true only when the wrapped AcDbDabase was created via a call to ReadDwgFile(). For databases that are open in the drawing editor, the value of AutoDelete is false.

I think it's a bit silly for everyone to be debating this issue when the value of that property literally and definitively answers that question for many (but not all) objects, don't you agree?

If we're going to debate the question of 'To Dispose or not to Dispose', it might help if everyone including the audience, become a bit more familiar with the inner workings of DisposableWrapper, and the fact that any managed wrapper that represents a native object that derives from AcRxObject, must derive from DisposableWrapper, regardless of whether it must be disposed or not.

Strange - I didn't get that comment through.

Sorry, I just brought that window forward and noticed some message about a 'timeout'.

Kerry · « **Reply #14 on:** August 24, 2012, 12:29:17 AM »

Tony, et al

Regarding autoDelete :
Under what circumstances would the autoDelete property be false ?

The constructors for (say) a line sets the property to true through the base class.

ie :

Code - C#: [Select]

 public unsafe Line(Point3d pointer1, Point3d pointer2) : base(ptr, true)
{
    AcDbLine* modopt(IsConst) modopt(IsConst) linePtr;
    void* voidPtr = AcHeapOperators.allocRawMem(0x18L);
    AcDbLine* linePtr2 = (AcDbLine*) voidPtr;
    try
    {
        linePtr = AcDbLine.{ctor}((AcDbLine* modopt(IsConst) modopt(IsConst)) voidPtr, 
                                          (AcGePoint3d modopt(IsConst)* modopt(IsImplicitlyDereferenced)) ((long) &pointer1), 
                                          (AcGePoint3d modopt(IsConst)* modopt(IsImplicitlyDereferenced)) ((long) &pointer2));
    }
    fault
    {
        ___CxxCallUnwindDelDtor(AcHeapOperators.delete, (void*) linePtr2);
    }
    IntPtr ptr = (IntPtr) linePtr;
}
 
 
 

The Curve base to Line :

Code - C#: [Select]

protected internal Curve(IntPtr unmanagedObjPtr, 
       [MarshalAs(UnmanagedType.U1)] bool autoDelete) : base(unmanagedObjPtr, autoDelete)
{
}
 

with this being the dependency chain

Code - C#: [Select]

[TypeDescriptionProvider("Autodesk.AutoCAD.ComponentModel.TypeDescriptionProvider`1[[Autodesk.AutoCAD.DatabaseServices.Line, acdbmgd]], acdbmgd"), Wrapper("AcDbLine")]
public class Line : Curve
{
    // Methods
    public Line();
    public Line(Point3d pointer1, Point3d pointer2);
    protected internal Line(IntPtr unmanagedObjPtr, [MarshalAs(UnmanagedType.U1)] bool autoDelete);
    internal unsafe AcDbLine* GetImpObj();
 
    //<..>
}
 
[TypeDescriptionProvider("Autodesk.AutoCAD.ComponentModel.TypeDescriptionProvider`1[[Autodesk.AutoCAD.DatabaseServices.Curve, acdbmgd]], acdbmgd"), Wrapper("AcDbCurve")]
public abstract class Curve : Entity
{
    // Methods
    protected internal Curve(IntPtr unmanagedObjPtr, [MarshalAs(UnmanagedType.U1)] bool autoDelete);
    public static Curve CreateFromGeCurve(Curve3d geCurve);
    public static Curve CreateFromGeCurve(Curve3d geCurve, Tolerance tolerance);
    public static Curve CreateFromGeCurve(Curve3d geCurve, Vector3d __unnamed001);
    public static Curve CreateFromGeCurve(Curve3d geCurve, Vector3d __unnamed001, Tolerance tolerance);
     //<..>
}
 
[Wrapper("AcDbObject"), TypeDescriptionProvider("Autodesk.AutoCAD.ComponentModel.TypeDescriptionProvider`1[[Autodesk.AutoCAD.DatabaseServices.DBObject, acdbmgd]], acdbmgd")]
public abstract class DBObject : Drawable
{
    //<..> 
 
    // Methods
    private void !DBObject();
    static DBObject();
    protected internal DBObject(IntPtr unmanagedObjPtr, [MarshalAs(UnmanagedType.U1)] bool autoDelete);
    //<..>
}
 
[Wrapper("AcGiDrawable")]
public abstract class Drawable : RXObject
{
    // Methods
    protected internal Drawable(IntPtr unmanagedPointer, [MarshalAs(UnmanagedType.U1)] bool autoDelete);
    //<..>
}
 
[Wrapper("AcRxObject")]
public abstract class RXObject : DisposableWrapper, ICloneable
{
    // Methods
    protected internal RXObject(IntPtr unmanagedPointer, [MarshalAs(UnmanagedType.U1)] bool autoDelete);
    //<..>
}
 
public abstract class DisposableWrapper : MarshalByRefObject, IDisposable
{
    //<..>
    // Methods
    private void !DisposableWrapper();
    protected DisposableWrapper();
    [SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
    protected DisposableWrapper(IntPtr unmanagedPointer, [MarshalAs(UnmanagedType.U1)] bool autoDelete);
    private void ~DisposableWrapper();
    internal void Attach(IntPtr unmanagedPointer, [MarshalAs(UnmanagedType.U1)] bool autoDelete);
    [EditorBrowsable(EditorBrowsableState.Advanced), SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
    public static DisposableWrapper Create(Type type, IntPtr unmanagedPointer, [MarshalAs(UnmanagedType.U1)] bool autoDelete);
    //<..>
}
 
[Serializable, ComVisible(true)]
public abstract class MarshalByRefObject
{
    //<..>
 
    // Methods
     //<..>
 
 
[ComVisible(true)]
public interface IDisposable
{
    // Methods
    void Dispose();
}
 
 

Just an aside.
It pleases me immensely to see the level of discussion on these subjects.
Thanks to all who are participating and attempting to clear up concepts that have been in dispute for years.

Regards,
Kerry

News:

Author Topic: Kean Walmsley on Dispose() (Read 8439 times)

TheMaster

Kean Walmsley on Dispose()

TheMaster

Re: Kean Walmsley on Dispose()

TheMaster

Re: Kean Walmsley on Dispose()

Keith™

Re: Kean Walmsley on Dispose()

TheMaster

Re: Kean Walmsley on Dispose()

TheMaster

Re: Kean Walmsley on Dispose()

Keith™

Re: Kean Walmsley on Dispose()

Jeff H

Re: Kean Walmsley on Dispose()

Kean

Re: Kean Walmsley on Dispose()

Keith™

Re: Kean Walmsley on Dispose()

TheMaster

Re: Kean Walmsley on Dispose()

Keith™

Re: Kean Walmsley on Dispose()

Kerry

Re: Kean Walmsley on Dispose()

TheMaster

Re: Kean Walmsley on Dispose()

Kerry

Re: Kean Walmsley on Dispose()