The Moth

Namespace System.Reflection

    <AttributeUsage(AttributeTargets.Assembly, AllowMultiple:=False)> _

    Public Class AssemblyFileVersionAttribute

        Inherits Attribute

        Private mVersion As String

        Public ReadOnly Property Version() As String

            Get

                Return mVersion

            End Get

        End Property

        Sub New(ByVal aVersion As String)

            If aVersion Is Nothing Then

                Throw New ArgumentNullException("version")

            End If

            mVersion = aVersion

        End Sub

    End Class

End Namespace

        // declarations

        private Thread mSendNextThread;            // worker thread

        private bool mStayAlive;    // for controlling the thread termination

        private Queue mQue;                        // buffer of jobs

        private ManualResetEvent mWaitEvent;// signal the thread to wake up

        // Initialisation logic

        public void Start(){

            Console.WriteLine("*********");

            Console.WriteLine("Start");

            mQue = new Queue();

            mWaitEvent = new ManualResetEvent(false);

            mStayAlive = true;

            mSendNextThread = new Thread(new ThreadStart(OnMyOwnThread));

            mSendNextThread.Start();

        }

        // Tear down logic

        public void Stop(){

            Console.WriteLine("Stop request");

            lock (mQue.SyncRoot){

                mQue.Clear();

                // kill the thread

                mWaitEvent.Reset();

                Thread.Sleep(10);

                mStayAlive = false;

                mWaitEvent.Set();

                Thread.Sleep(10);

                mSendNextThread = null;

            }

            Console.WriteLine("Stopped");

        }

        // queue more jobs

        public void MoreInput(object someInput){

            Console.WriteLine("More Input: " + someInput.ToString());

            lock (mQue.SyncRoot){

                mQue.Enqueue(someInput);

            }

            mWaitEvent.Set();

        }

        // process jobs

        public void OnMyOwnThread(){

            while (mStayAlive){

                if (mWaitEvent.WaitOne()){

                    mWaitEvent.Reset();

                    while (mQue.Count > 0){    //Whether we do the looping depends

                                            //on the specifics of DoWork

                        if (!mStayAlive){

                            break;

                        }

                        this.DoWork2();

                        mWaitEvent.Reset();

                    }

                }

            }

            Console.WriteLine("Thread exiting");

        }

        private void DoWork2(){

            object queObj = null;

            lock (mQue.SyncRoot){

                if (mQue.Count > 0){

                    queObj = mQue.Dequeue();

                }

            }

            // do some long processing with this job/input

            if (queObj != null){

                Console.WriteLine("Processing: " + queObj.ToString());

                Thread.Sleep(300);//LONG PROCESSING

                Console.WriteLine("Processed " + Environment.TickCount.ToString());

            }

        }

        /// <summary>

        /// This function opens a handle to an existing message queue based on 

        /// a message queue handle.

        /// </summary>

        /// <param name="hSrcProc">[in] Handle to a source process that owns the 

        /// hMsgQ message queue handle. </param>

        /// <param name="hMsgQ">[in] Handle to a message queue returned by the 

        /// CreateMsgQueue function.</param>

        /// <param name="lpOptions">[in] Pointer to an MSGQUEUEOPTIONS structure 

        /// that sets the properties of the message queue.</param>

        /// <returns>Returns a handle to a message queue, or returns NULL if the 

        /// queue could not be opened.</returns>

        [DllImport("coredll.dll", SetLastError=true)]

        public static extern IntPtr OpenMsgQueue(IntPtr hSrcProc, IntPtr hMsgQ,    

            MsgQueueOptions lpOptions);

    Private Function DoWork2() As Boolean

        ' If I don't have a requester then I can't do anything with the input 

        ' so ignore it (and don't obtain the lock!)

        Dim req As ForMyPending = Nothing

        req = Me.FindFreeRequester

        If req Is Nothing Then

            Return False

        End If

        ' Get the next object from the queue

        Dim queObj As ForMyQueue = Nothing

        SyncLock mQue.SyncRoot

            If mQue.Count > 0 Then

                queObj = DirectCast(mQue.Dequeue(), ForMyQueue)

            End If

        End SyncLock

        ' Deal with the next object from the queue without holding the lock!

        If Not queObj Is Nothing Then

            If queObj.ReqArgs.MaxNumResponses <> 0 Then'chance for client to cancel

                req.Deleg = queObj.Deleg

                If req.Requester.Request(queObj.ReqArgs, queObj.State) = False Then

                    If Not req.Deleg Is Nothing Then

                        req.Deleg.Invoke(Me, ReplyArgs.Empty)'failed

                        req.Deleg = Nothing'otherwise it wil never be reused again!

                    End If

                End If

            End If

        End If

        Return True

    End Function