threading question

[Jon Pope]

I've got a basic question about threading which I'm hoping someone here will
be able to answer:

Let's say my calling CallingClass has instantiated and started a worker
thread. When my worker thread has completed, it fires an event which
CallingClass has an event handler listening for.

My question is this: in which thread is that event handler operating? The
worker's or CallingClass's? The issue I'm running into is that if I include
a Worker.Join() call within the event handler on CallingClass, it just sits
there forever waiting for the worker thread to stop.

Is this even the proper to signal the end of a thread? I have some
processing that is waiting for the thread is completely finish and shutdown,
and I need a way to find that out. Any help someone can provide would be
greatly appreciated.

Cheers, Jon

[Sijin Joseph]

The event handler is ruiing on the worker's thread, you can see this by
placing a breakpoint in the event handlers and then looking at the
Threads window to see the thread that is active. Or you can use the
ThreadID's to check which thread is active, just dump the ThreadID's to
the console.

Sijin Joseph
http://www.indiangeek.net
http://weblogs.asp.net/sjoseph

Jon Pope wrote:

I've got a basic question about threading which I'm hoping someone here will
be able to answer:

Let's say my calling CallingClass has instantiated and started a worker
thread. When my worker thread has completed, it fires an event which
CallingClass has an event handler listening for.

My question is this: in which thread is that event handler operating? The
worker's or CallingClass's? The issue I'm running into is that if I include
a Worker.Join() call within the event handler on CallingClass, it just sits
there forever waiting for the worker thread to stop.

Is this even the proper to signal the end of a thread? I have some
processing that is waiting for the thread is completely finish and shutdown,
and I need a way to find that out. Any help someone can provide would be
greatly appreciated.

Cheers, Jon

[Jon Pope]

Thanks, Patty, I appreciate your help. Just so I'm clear: what you're
suggesting is that I pass in a delegate to my Worker thread which points to
a subroutine within my CallingClass. This subroutine is what I want to call
from within my thread when it's done. Is this accurate?

Jon

"Patty O'Dors" <Pa********@discussions.microsoft.com> wrote in message
news:55**********************************@microsof t.com...

If you are using (or there is a possibility that you will be using) the
CallingClass as part of a user interface, then when you want the worker to
'fire an event' that will tell the calling class that the worker is
finished,
you should really transfer control back to the thread that the calling
class
is running in, to ensure this happens, you need to use a delegate which
you
invoke by calling the BeginInvoke method of the calling class (you might
need
to derive CallingClass from something in order to do this). It's probably
a
good idea to do this anyway, as it enables you to be sure that the
boundary
between classes is the same as the boundary between threads, and you
haven't
got a thread 'calling into' another thread's class.

"Jon Pope" wrote:

I've got a basic question about threading which I'm hoping someone here
will
be able to answer:

Let's say my calling CallingClass has instantiated and started a worker
thread. When my worker thread has completed, it fires an event which
CallingClass has an event handler listening for.

My question is this: in which thread is that event handler operating?
The
worker's or CallingClass's? The issue I'm running into is that if I
include
a Worker.Join() call within the event handler on CallingClass, it just
sits
there forever waiting for the worker thread to stop.

Is this even the proper to signal the end of a thread? I have some
processing that is waiting for the thread is completely finish and
shutdown,
and I need a way to find that out. Any help someone can provide would be
greatly appreciated.

Cheers, Jon

[Patty O'Dors]

Not quite, nearly though.
inline

"Jon Pope" wrote:

Thanks, Patty, I appreciate your help. Just so I'm clear: what you're
suggesting is that I pass in a delegate
When I do it, I don't pass the delegate in. Rather, I define it outside of
both classes (or within one of them if you want, it makes it like a nested
class) but anyway it doesn't need to be a class member. A delegate is a thing
in its own right - where you define it depends on how you want to organise
your project conceptually.

to my Worker thread which points to a subroutine within my CallingClass. This subroutine is what I want to call
from within my thread when it's done. Is this accurate?

It only points to the method once it's instantiated. Don't forget delegates
have a type definition and an instantiation just like classes. IMHO, they
should be instantiated on one line of code, which also tells them (for the
first and only time) what method they point to, and invoked on the next,
thereafter, they're forgotten and the instance of the delegate goes out of
scope.
Remember it's completely fine for the worker thread to hold a variable
reference to the main form which is operating in another (the primary)
thread, as long as the only method it calls on it is BeginInvoke, in order to
transfer control back to the primary thread.
Jon

"Patty O'Dors" <Pa********@discussions.microsoft.com> wrote in message
news:55**********************************@microsof t.com...

If you are using (or there is a possibility that you will be using) the
CallingClass as part of a user interface, then when you want the worker to
'fire an event' that will tell the calling class that the worker is
finished,
you should really transfer control back to the thread that the calling
class
is running in, to ensure this happens, you need to use a delegate which
you
invoke by calling the BeginInvoke method of the calling class (you might
need
to derive CallingClass from something in order to do this). It's probably
a
good idea to do this anyway, as it enables you to be sure that the
boundary
between classes is the same as the boundary between threads, and you
haven't
got a thread 'calling into' another thread's class.

"Jon Pope" wrote:

I've got a basic question about threading which I'm hoping someone here
will
be able to answer:

Let's say my calling CallingClass has instantiated and started a worker
thread. When my worker thread has completed, it fires an event which
CallingClass has an event handler listening for.

My question is this: in which thread is that event handler operating?
The
worker's or CallingClass's? The issue I'm running into is that if I
include
a Worker.Join() call within the event handler on CallingClass, it just
sits
there forever waiting for the worker thread to stop.

Is this even the proper to signal the end of a thread? I have some
processing that is waiting for the thread is completely finish and
shutdown,
and I need a way to find that out. Any help someone can provide would be
greatly appreciated.

Cheers, Jon