Can lock into a dispose?

[BLUE]

I've a class A that implements IDisposable interface and has a method that
start a thread.
In Dispose(bool) can I use the lock keyword to wait for thread exit before
disposing resources it use or it's enough to pay attention when disposing
objects of type A from "consumer" classes?
Thanks,
Luigi.

[Christof Nordiek]

"Moty Michaely" <Mo*****@gmail. comschrieb im Newsbeitrag
news:11******** **************@ r3g2000prh.goog legroups.com...

On May 21, 12:47 pm, "Christof Nordiek" <[e-mail] wrote:

>"Moty Michaely" <Moty...@gmail. comschrieb im
Newsbeitragnew s:11*********** ***********@n15 g2000prd.google groups.com...

>So, the if(disposing) statement would never be entered, when the
Finalizer
is called. And Dispose of components shouldn't be called by the
Finalizer
anyway.

>Christof

Hi,

What if things should be done without trusting the developer to call
Dispose?

Then the compononents (and their components ....) themselves are eligable
for finalization will be cleaned up by their own finalizer. So calling
Dispose isn't necessary anymore.
That's way classes like Form and Component implement the Dispose(bool)
method. By this inheriting classes can easily implement the cleanup of
managed resources, wich should only occur during disposing, and cleanup
of
managed resources, wich has to occur during disposing aswell as during
finalization .

Christof

But again,
What if the I need to serialize a class when it's about to be
disposed?
I would do it in the finalizer, right? (with dispose(false))

No, this is not a good place for such things.
Finalizer should only clean up unmanaged resources, nothing else.

Also Dispose is also not a good place for serialization. It should only
cleanup managed and unmanged resources.
If you use Dispose for storing data or something else. Then you should
clearly communicate that to the caller of the class, and make it clear, that
data may be lost, if Dispose isn't called.
I don't know the scenario, you are talking about, but I guess, the is a
better way (like implementing an ISaveable interface or so).

Christof

[Chris Mullins [MVP]]

You can use a lock() (or a ReaderWriterLoc k, etc) in a Dispose() method.
There's no trouble with this at all.

A Dispose method, after all, is just a standard method running on the thread
of whatever called Dispose().

Where you really, really don't want to use a lock is inside a Finalizer. The
CLR uses a single thread to call finalizers, and if you block this thread,
finalization cannot happen and your application is now screwed.

--
Chris Mullins, MCSD.NET, MCPD:Enterprise , Microsoft C# MVP
http://www.coversant.com/blogs/cmullins

"BLUE" <bluewrote in message news:OT******** ******@TK2MSFTN GP04.phx.gbl...

I've a class A that implements IDisposable interface and has a method that
start a thread.
In Dispose(bool) can I use the lock keyword to wait for thread exit before
disposing resources it use or it's enough to pay attention when disposing
objects of type A from "consumer" classes?
Thanks,
Luigi.