Пример #1
0
        private void ProcessOverride(ThreadCommand task)
        {
            if (task.Executed == null)
            {
                task.State = COMMAND_STATE.STATE_CANCEL;
                return;
            }
            if ((task.CanExecuted != null))
            {
                bool canExecuted = false;
                if (task.IsUseDispatcher)
                {
                    if (task.CallBackDispather != null)
                    {
                        canExecuted = (bool)task.CallBackDispather.Invoke(System.Windows.Threading.DispatcherPriority.Normal,
                            task.CanExecuted, task.Parameter);
                    }
                }
                else
                {
                    canExecuted = task.CanExecuted(task.Parameter);
                }
                if (!canExecuted)
                {
                    task.State = COMMAND_STATE.STATE_CANCEL;
                    return;
                }
            }
            try
            {
                task.Executed(task.Parameter);
            }
            catch (Exception ex)
            {
                _logger.Fatal(null, ex);
            }

            if ((task.Complete != null))
            {
                if (task.IsUseDispatcher)
                {
                    if (task.CallBackDispather != null)
                    {
                        task.CallBackDispather.Invoke(System.Windows.Threading.DispatcherPriority.Normal,
                            task.Complete, task.Parameter);
                    }
                }
                else
                {
                    task.Complete(task.Parameter);
                }
            }
            task.State = COMMAND_STATE.STATE_COMPLETE;
        }
Пример #2
0
        public bool Enqueue(ThreadCommand task, THREADED_ENQUEUE_TYPE enqueueType = THREADED_ENQUEUE_TYPE.CLEAR_AND_ADD)
        {
            if (task == null)
            {
                return false;
            }

            if (task != null)
            {
                lock (_queueSyncObject)
                {
                    switch (enqueueType)
                    {
                        case THREADED_ENQUEUE_TYPE.NORMAL:
                            _queue.Add(task);
                            task.State = COMMAND_STATE.STATE_WAIT;
                            break;
                        case THREADED_ENQUEUE_TYPE.CLEAR_AND_ADD:
                            for (int i = 0; i < _queue.Count; i++)
                            {
                                if (_queue[i].CommandID == task.CommandID)
                                {
                                    _queue[i].State = COMMAND_STATE.STATE_CANCEL;
                                    _queue.RemoveAt(i);
                                    i--;
                                }
                            }
                            _queue.Add(task);
                            task.State = COMMAND_STATE.STATE_WAIT;
                            break;
                        default:
                            break;
                    }

                    bool eventFlag = _existTaskEvent.WaitOne(0, false);

                    if ((eventFlag == false) && (_queue.Count > 0))
                    {
                        _existTaskEvent.Set();
                    }
                }
            }

            return true;
        }
Пример #3
0
 public virtual ThreadCommand PreprocessEnqueuingTask(ThreadCommand task,out THREADED_ENQUEUE_TYPE enqueueType)
 {
     enqueueType = THREADED_ENQUEUE_TYPE.NORMAL;
     return task;
 }