Hi Alan,
Here is how your class and thread method handler maylook like...
Class MyThreadWrapper
private _myThread
// (Important: Default state should be signaled, i.e. True)
private _continueEvent System.Threading.ManualResetEvent
private enumerated type _state (pause, stop, start, resume)
method Pause
{ set _state = pause, _continueEvent.Reset() }
method Stop
{ set _state = stop, _continueEvent.Set() }
method Start
{ set _state = start
_myThread.Start()
}
method Resume
{ set _state = resume, _continueEvent.Set() }
procedure DoSomething()
loop
_continueEvent.Wait(-1) // Wait infinitely on the manual reset event
if (_state == stop) { break; }
Copy a file to a location
Update database record
Read the file content
Write the content to a log file
end loop
What we are doing here is that the thread loop will just wait for
ManualResetEvent to be in signaled state (_continueEvent.Set()) before
continuing with every iteration in the loop. The event will be in this state
when the thread first starts. When we call Pause the_continueEvent will be in
non-signaled state and the thread will finish the current loop iteration and
then before begining the next iteration will wait for the event to be in
signaled state. When we call Resume after some time the _continueEvent will
be set to signaled state and the thread will start running again.
Calling Stop() when we are in running state (start or resume) will cause the
loop to terminate after completing its current iteration. Calling Stop() when
we are in pause state will set the _continueEvent to signaled state and
immediately since the _state is stop, the loop will break and the thread will
end safely.
Let me know if this helps.
--
Regards,
Aditya.P
"Alan T" wrote:
I partially understand your approach but not quite sure how to implement the
stop and resume.
The syntax is not proper, I just show the meaning:
Class MyThreadWrapper
private _myThread
private enumerated type _state (pause, stop, start, resume)
method Pause
{ set _state = pause}
method Stop
{ set _state = stop}
method Start
{ set _state = start
_myThread.Start()
}
method Resume
{ set _state = resume}
If the user calls MyThreadWrapper.State(),
_state will be set to start and calls
constructor :
_myThread = new Thread(new ThreadStart(this.DoSomething));
In the _myThread, it executes DoSomething(), to do a loop, for example 50
times:
procedure DoSomething()
loop
Copy a file to a location
Update database record
Read the file content
Write the content to a log file
end loop
1) If the user calls MyThreadWrapper.Start()
2) If the user calls MyThreadWrapper.Pause(), how do I guarrantee the loop
stops at after the
"Write the content to a log file" ? By checking the value of the _state?
procedure DoSomething()
loop
Copy a file to a location
Update database record
Read the file content
Write the content to a log file
while _state == pause
{
// no statement, so stay in this dummy while loop
}
end loop
2) What if the users calls MyThreadWrapper.Stop() ?
procedure DoSomething()
loop
Copy a file to a location
Update database record
Read the file content
Write the content to a log file
while _state == pause
{
// no statement
}
if _state == stop
{
exit;
}
end loop
Should it be like this:
procedure Stop()
{
_state = stop;
_myThread.abort();
}
Please comment
"Adityanand Pasumarthi" <Ad******************@discussions.microsoft.com>
wrote in message news:55**********************************@microsof t.com...
Hi Alan,
Suspending and then Aborting a thread may cause data integrity problems if
your thread in middle of updating some business data. And anyway these two
methods are deprecated in .Net 2.0.
If your thread is doing some routine data related manipulations in a loop
(or some loop kind of thing), then implement a small class that wraps your
thread and provide "Pause", "Resume" and "Stop" methods on that class.
Define
your thread handler method as a method inside the class and based on the
state of the class object ("Pause", "Resume" and "Stop") let the thread
handler method pause, resume and stop by itself.
This way you gurantee the data safety in your application and also provide
a
decent way of pausing, resuming and stopping the work done by your thread.
--
Regards,
Aditya.P
"Alan T" wrote:
I will do several things in my thread:
Copy a file to a location
Update database record
Read the file content
Write the content to a log file
If I call Thread.Abort(), it may be possible to stop at the middle of the
something ?
