Dispose pattern improvement?

  • Thread starter Thread starter Andreas Huber
  • Start date Start date
A

Andreas Huber

Hi there

Is there a reason why .NET framework base classes implementing IDisposable
(like e.g. System.ComponentModel.Component) do not prevent multiple calls to
the protected virtual void Dispose( bool disposing ) function?

Derived classes would then no longer need to check whether they have been
disposed already and the associated bool member wouldn't be necessary
either.

Example code:

class Base : IDisposable
{
private bool disposed = false;

~Base()
{
if ( !this.disposed ) // *** here ***
{
Dispose( false );
this.disposed = true;
}
}

public void Dispose()
{
if ( !this.disposed ) // *** here ***
{
Dispose( true );
GC.SuppressFinalize( this );
this.disposed = true;
}
}

public void SomeMethod()
{
if ( this.Disposed )
{
throw new ObjectDisposedException( "Base" );
}

// ...
}

// This property is necessary so that subclass methods can check whether
// the object has been disposed.
protected bool Disposed
{
get { return this.disposed; }
}

protected virtual void Dispose( bool disposing )
{
if ( disposing )
{
// release my managed resources
}

// release my unmanaged resources
}
}


class Derived : Base
{
public void SomeOtherMethod()
{
if ( this.Disposed )
{
throw new ObjectDisposedException( "Derived" );
}

// ...
}

protected override void Dispose( bool disposing )
{
try
{
if ( disposing )
{
// release my managed resources
}

// release my unmanaged resources
}
finally
{
base.Dispose( disposing );
}
}
}
 
Andreas Huber said:
Is there a reason why .NET framework base classes implementing IDisposable
(like e.g. System.ComponentModel.Component) do not prevent multiple calls to
the protected virtual void Dispose( bool disposing ) function?

Derived classes would then no longer need to check whether they have been
disposed already and the associated bool member wouldn't be necessary
either.
Click to expand...

In what way would the associated bool member not be necessary? You'd
still need to check whether or not the object had been disposed for
methods *other* than dispose itself (eg writing to a stream which has
already been disposed).
 
Jon said:
In what way would the associated bool member not be necessary? You'd
still need to check whether or not the object had been disposed for
methods *other* than dispose itself (eg writing to a stream which has
already been disposed).
Click to expand...

I'm not sure I understand what you mean as that's what the protected
Disposed property in the base class would be for...

I quote from my original message:
class Base : IDisposable
{ [snip]
// This property is necessary so that subclass methods can check whether
// the object has been disposed.
protected bool Disposed
{
get { return this.disposed; }
} [snip]
}
Click to expand...
[snip]
class Derived : Base
{
public void SomeOtherMethod()
{
if ( this.Disposed )
{
throw new ObjectDisposedException( "Derived" );
}

// ...
}
Click to expand...
[snip]

Regards,

Andreas
 
Andreas Huber said:
I'm not sure I understand what you mean as that's what the protected
Disposed property in the base class would be for...
Click to expand...

Ah - sorry, I thought you were suggesting that the bool member in your
example wouldn't be necessary. I wasn't entirely clear about what you
were suggesting...
 
Jon said:
Ah - sorry, I thought you were suggesting that the bool member in your
example wouldn't be necessary. I wasn't entirely clear about what you
were suggesting...
Click to expand...

I see, sorry for being unclear...

Regards,

Andreas
 
Back
Top