C#

Zoltan Balazs wrote:

As I know, this is possible in VS 2008, but not in VS 2005

jharker1987 wrote:

was getting Security.SecurityException because my program was attempting to access the "LocalMachine [HKLM]" Key

jharker1987 wrote:

hanks windows error reporting [not]. actually took quite a few [several] hours to work this out

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ManualResetExample {

    public class MockModule {

        public MockModule(String name) {
            Name = name;
        }

        public String Name { get; private set; }

        private Object syncLock = new Object();
        private EventHandler onDone;
        public event EventHandler OnDone {
            add {
                lock (syncLock) {
                    onDone += value;
                }
            }
            remove {
                lock (syncLock) {
                    onDone -= value;
                }
            }
        }
        private void FireOnDone(Object sender, EventArgs args) {
            if (onDone != null) {
                onDone(sender, args);
            }
        }

        public void StartWork() {
            ThreadPool.QueueUserWorkItem(new WaitCallback(WorkThread));
        }

        private void WorkThread(Object arg) {
            try {
                for (int i = 0; i < 5; i++) {
                    Thread.Sleep(250);
                    Console.WriteLine("{0} working", Name);
                }
            } finally {
                FireOnDone(this, new EventArgs());
            }
        }

    }

    public class WorkCompleteEventArgs : EventArgs {
        public WorkCompleteEventArgs(Boolean wasSuccessful) {
            Success = wasSuccessful;
        }
        public Boolean Success { get; private set; }
    }

    internal class ModuleSyncBlock {
        public ModuleSyncBlock(MockModule module) {
            Reset = new ManualResetEvent(false);
            MockModule = module;
        }
        public ManualResetEvent Reset { get; set; }
        public MockModule MockModule { get; set; }
    }

    public class ModuleManager {
        List<modulesyncblock> modules;
        List<mockmodule> mocks;

        public ModuleManager() {
            modules = new List<modulesyncblock>();
            mocks = new List<mockmodule>();
            //add some fake ones
            mocks.Add(new MockModule("One"));
            mocks.Add(new MockModule("Two"));
            mocks.Add(new MockModule("Three"));
            mocks.Add(new MockModule("Four"));
            mocks.Add(new MockModule("Five"));
        }

        
        public void StartAll() {
            ThreadPool.QueueUserWorkItem(new WaitCallback(RunInternal));   
        }

        private void RunInternal(Object arg) {
            List<manualresetevent> manuals = new List<manualresetevent>();
            mocks.ForEach(m => modules.Add(new ModuleSyncBlock(m)));
            modules.ForEach(m => manuals.Add(m.Reset));
            modules.ForEach(m => {
                m.MockModule.OnDone += new EventHandler(MockModule_OnDone);
                m.MockModule.StartWork();
            });
            if (WaitHandle.WaitAll(manuals.ToArray(), new TimeSpan(0, 0, 30), false)) {
                FireOnWorkComplete(this, new WorkCompleteEventArgs(true));
            } else {
                FireOnWorkComplete(this, new WorkCompleteEventArgs(false));
            }
        }
        void MockModule_OnDone(object sender, EventArgs e) {
            ModuleSyncBlock msb = modules.Find(m => ReferenceEquals(sender, m.MockModule));
            if (msb != null) {
                Console.WriteLine(msb.MockModule.Name + " Finished");
                msb.Reset.Set(); // signal that we're done.
            }
        }

        private Object syncLockA = new Object();
        private EventHandler<workcompleteeventargs> onWorkComplete;
        public event EventHandler<workcompleteeventargs> OnWorkComplete {
            add {
                lock (syncLockA) {
                    onWorkComplete += value;
                }
            }
            remove {
                lock (syncLockA) {
                    onWorkComplete -= value;
                }
            }
        }
        private void FireOnWorkComplete(Object sender, WorkCompleteEventArgs args) {
            if (onWorkComplete != null) {
                onWorkComplete(sender, args);
            }
        }

    }
}
</workcompleteeventargs></workcompleteeventargs></manualresetevent></manualresetevent></mockmodule></modulesyncblock></mockmodule></modulesyncblock>