Dispose pattern in class derivation

Hello everyone,


For the Dispose pattern, here is what MSDN mentioned,

http://msdn2.microsoft.com/en-us/lib...5e(VS.80).aspx

--------------------
Implement the dispose design pattern on a base type that commonly has derived types that hold onto resources, even if the base type does not.
--------------------

Could anyone let me know what means "on a base type that commonly has derived types that hold onto resources" and "the base type does not"? Could anyone show some pseudo code please?


thanks in advance,
George

Roughly something like this: base has no resources attached to it, but derived has, so we implement a "dispose" function (this is just to show the concept, not compilable C++ or C# code).

Code:

class base
{
   ... 
public:
   virtual dispose();
};


class derived: public base
{
private:
    someresource res;

public:
   virtual dispose()  { relase(res); }
};

--
Mats

Well, here's a quick example:

Say you have an AbstractDataSource class that's an abstract base class whose child classes handle reading data from specific sources (local file, database, network, etc.) Those child classes may have resources such as file handles and TCP connections that we'd like to have a Dispose() method to clean up. So we put it in the base class, even though the base class itself doesn't have any resources, so that our children can override it and clean themselves up.

Thanks Mats and Cat,


Question answered.

Originally Posted by Cat

Well, here's a quick example:

Say you have an AbstractDataSource class that's an abstract base class whose child classes handle reading data from specific sources (local file, database, network, etc.) Those child classes may have resources such as file handles and TCP connections that we'd like to have a Dispose() method to clean up. So we put it in the base class, even though the base class itself doesn't have any resources, so that our children can override it and clean themselves up.

regards,
George

One question concerning Dispose:

Is it ok the resuse "Dispose" just for Raising an Disposed-Event, so listeners can assume the object is dead and react to that - although the object never held any unmanaged resources and may still be referenced?

Currently in my game (which is seperated into Model, View, Control) whenever something gets destroyed* (e.g. a tree or monster) i call the Dispose method, that raises an event, which causes the model to unregister that object, and usually the view also listens to that event and also removes the visual representation (if any).

Fortunately even if what i did is a no-go, its easy to refactor


*by destroyed i really mean that the object can be destroyed.
When a tree first gets "destroyed" it remains in "dead" ("destroyed") state for a few seconds, before it is really removed from the model (so Disposed is called).

Thanks for sharing experience, Raven!

Originally Posted by Raven Arkadon

One question concerning Dispose:

Is it ok the resuse "Dispose" just for Raising an Disposed-Event, so listeners can assume the object is dead and react to that - although the object never held any unmanaged resources and may still be referenced?

Currently in my game (which is seperated into Model, View, Control) whenever something gets destroyed* (e.g. a tree or monster) i call the Dispose method, that raises an event, which causes the model to unregister that object, and usually the view also listens to that event and also removes the visual representation (if any).

Fortunately even if what i did is a no-go, its easy to refactor


*by destroyed i really mean that the object can be destroyed.
When a tree first gets "destroyed" it remains in "dead" ("destroyed") state for a few seconds, before it is really removed from the model (so Disposed is called).

regards,
George