Inheritance: System.EventArgs
 protected override void OnAsyncOperationFinish(Object sender, ThreadEventArgs args)
 {
     if ((args.Success) && (args.MethodBase == Method(runMethod)))
     {
         _control.ShowSomething();
     }
 }
 protected override void OnAsyncOperationFinish(Object sender, ThreadEventArgs args)
 {
     if ((args.Success) && (args.MethodBase == MethodBase(runMethod)))
     {
         _view.ShowSomething();
     }
     if ((args.Success) && (args.MethodBase == MethodBase(runMethodWithCancellationLogic)))
     {
         _view.ShowSomething();
     }
 }
        /// <summary>
        /// As the async op is completed, the editUserWindow must be hidden.
        /// </summary>
        public override void OnAsyncCallStop(object sender, ThreadEventArgs teargs)
        {
            SimpleDelegate saveUser = this.SaveUser;

            if (saveUser.Method == teargs.MethodBase)
            {
                int userId = (int)teargs.ReturnValue;
                if (userId > 0)
                {
                    base.parentWindow.Destroy();
                }
            }
        }
        public override void OnAsyncCallStop(object sender, ThreadEventArgs teargs)
        {
            Console.WriteLine("ASYNC CALL STOP");
            Console.WriteLine("{0},{1},{2}", teargs.ThreadId, teargs.MethodBase.ToString(), teargs.ReturnValue);
            SimpleDelegate deleteUser = this.DeleteUser;

            if (deleteUser.Method == teargs.MethodBase)
            {
                int userId = (int)teargs.ReturnValue;
                if (userId > 0)
                {
                    Console.WriteLine("userid = " + userId);
                    ftreeviewUsers.DeleteModelById(userId);
                }
            }
        }
        /// <summary>
        /// Take the first block of threads from the queue and remove it from the queue. 
        /// The contents of the block are the threads created by StartAsyncCall or StartAsyncCallList
        /// When all the threads from that block have finished invoke OnTransferCompleted to access the GUI
        /// </summary>
        /// <param name="args"></param>
        /// <param name="output"></param>
        private void StopAsyncMethod(ThreadEventArgs args, object output)
        {
            lock(_innerLock)
            {
                if (_threadDictionariesList.Count == 0)
                {
                    throw new Exception("Error trying to stop asynchronous call. You are most likely calling StopAsyncMethod more than once");
                }
                else
                {
                    Console.Out.WriteLine("*** stopping: " + _threadDictionariesList.Count);
                    for (int i = 0; i < _threadDictionariesList.Count; i++)
                    {
                        Dictionary<int, Thread> threadBlock = _threadDictionariesList[i];
                        if (threadBlock.ContainsKey(args.ThreadId))
                        {
                            Console.Out.WriteLine("threadBlog count:" + threadBlock.Count + "," + Thread.CurrentThread.ManagedThreadId);
                            if (threadBlock.Count > 0)
                            {
                                threadBlock.Remove(args.ThreadId);
                                _cancelRequests.Remove(args.ThreadId);
                                // FIXME: doing this, the args is populated with the last thread results,
                                // loosing the previous ones if the operation launched a group of threads
                                // in parallell
                                args.Success = args.Success && _operationSucess[args.ThreadId];
                                _operationSucess.Remove(args.ThreadId); ;
                                args.OperationType = _operationTypes[args.ThreadId];
                                _operationTypes.Remove(args.ThreadId); ;
                                args.ExceptionMsg += _exceptions[args.ThreadId];
                                _exceptions.Remove(args.ThreadId);

                                Console.Out.WriteLine("  now after removing:" + threadBlock.Count);
                                if (threadBlock.Count == 0)
                                {
                                    Console.Out.WriteLine("DEQUEUING DATA FROM STORAGE:" + Thread.CurrentThread.ManagedThreadId);
                                    _threadDictionariesList.RemoveAt(i);
                                    OnTransferCompleted(args.OperationType, args);
                                    break;
                                }
                            }
                        }
                    }

                }
            }
        }
 /// <summary>
 /// Stops the current thread passing in information about the thread itself, and any outcome information
 /// </summary>
 /// <param name="threadId">You can use the CurrentThread Abstract Controller's property or System.Threading.Thread.CurrentThread.ManagedThreadId</param>
 /// <param name="method">The method which is running. You can pass the method if its signature matches the SimpleDelegate</param>
 /// <param name="output">Any info you want to send. It could be a message, an exception or whatever you need</param>
 public void StopAsyncMethod(int threadId, SimpleDelegate method, object output)
 {
     ThreadEventArgs tea = new ThreadEventArgs(threadId, method, output);
     StopAsyncMethod(tea, output);
 }
 /// <summary>
 /// Stops the current thread passing in information about the thread itself, and any outcome information
 /// </summary>
 /// <param name="threadId">You can use the CurrentThread Abstract Controller's property or System.Threading.Thread.CurrentThread.ManagedThreadId</param>
 /// <param name="methodBase">The method who is running. You can call MethodBase(method), implemented in the Abstract Controller</param>
 /// <param name="output">Any info you want to send. It could be a message, an exception or whatever you need</param>
 public void StopAsyncMethod(int threadId, MethodBase methodBase, object output)
 {
     ThreadEventArgs tea = new ThreadEventArgs(threadId, methodBase, output);
     StopAsyncMethod(tea, output);
 }
 public abstract void OnTransferCompleted(object sender, ThreadEventArgs e);
 protected override void OnAsyncOperationFinish(object sender, ThreadEventArgs args)
 {
     _control.ShowMessage("OK!!!");
 }
        public void StopTransfer(int threadId, MethodBase methodBase, object output)
        {
            lock(this)
            {
                if (_asyncCallsCount > 0)
                {
                    _asyncCallsCount --;
                    if (_asyncCallsCount == 0)
                    {
                        _threadsPoolHash.Clear();
                        if (_baseTransferCompleteHandler != null)
                        {
                            ThreadEventArgs tea = new ThreadEventArgs(threadId, methodBase, output);
                            Delegate[] invList = _baseTransferCompleteHandler.GetInvocationList();
                            if (invList.Length > 0)
                            {
                                object[] parameters = { _transferType, tea };
                                invList[0].DynamicInvoke(parameters);

                                //_baseTransferCompleteHandler(_transferType, tea);
                            }
                            else
                            {
                                throw new NullReferenceException("BaseTransferCompleteEvent has no handler");
                            }
                        }
                    }
                }
            }
        }