manualresetevent

I'm a little confused over a ManualResetEvent that I'm using which doesn't appear to be unblocking. Anyone know why this might be the case? The scenario I've got is something along these lines. The real situation is quite complicated and I've not managed to isolate a section of code that's reasonable to post to reproduce the issue. EDIT I've updated the code example below. This is execute in a number of different dialogs and I have noticed that one of them hits the this.mre.WaitOne(); Then what happens is I get a "Server Busy" dialog, where I need to press 'switch to' or 'retry', which will

I feel like I should know the answer to this, but I'm going to ask anyway just in case I'm making a potentially catastrophic mistake. The following code executes as expected with no errors/exceptions: static void Main(string[] args) { ManualResetEvent flag = new ManualResetEvent(false); ThreadPool.QueueUserWorkItem(s => { flag.WaitOne(); Console.WriteLine("Work Item 1 Executed"); }); ThreadPool.QueueUserWorkItem(s => { flag.WaitOne(); Console.WriteLine("Work Item 2 Executed"); }); Thread.Sleep(1000); flag.Set(); flag.Close(); Console.WriteLine("Finished"); } Of course, as is usually the case

I am not sure which strategy to adopt...I am focusing on my operation getting completed, but I'd also like to keep performance issues to a min too...there is a method called Execute() which has to wait (run synchronously) until an operation completes. This operation happens on another thread. There are 2 ways to implement the same thing... By using ManualResetEvent void Execute() { taskHandle = new ManualResetEvent(false); . . //delegate task to another thread . . taskHandle.WaitOne(); } OR By using a simple while construct void Execute() { . . //delegate task to another thread . . while (

I implemented the following background processing thread, where Jobs is a Queue<T> : static void WorkThread() { while (working) { var job; lock (Jobs) { if (Jobs.Count > 0) job = Jobs.Dequeue(); } if (job == null) { Thread.Sleep(1); } else { // [snip]: Process job. } } } This produced a noticable delay between when the jobs were being entered and when they were actually starting to be run (batches of jobs are entered at once, and each job is only [relatively] small.) The delay wasn't a huge deal, but I got to thinking about the problem, and made the following change: static ManualResetEvent

Consider a Console application that starts up some services in a separate thread. All it needs to do is wait for the user to press Ctrl+C to shut it down. Which of the following is the better way to do this? static ManualResetEvent _quitEvent = new ManualResetEvent(false); static void Main() { Console.CancelKeyPress += (sender, eArgs) => { _quitEvent.Set(); eArgs.Cancel = true; }; // kick off asynchronous stuff _quitEvent.WaitOne(); // cleanup/shutdown and quit } Or this, using Thread.Sleep(1): static bool _quitFlag = false; static void Main() { Console.CancelKeyPress += delegate { _quitFlag =