public void Add(ITask task)
        {
            if (task == null)
                throw new ArgumentNullException();

            Add(new EnumerableTask(task));
        }

 /// <summary>
 /// public constructor
 /// </summary>
 public TaskLoggingHelperExtension(ITask taskInstance, ResourceManager primaryResources, ResourceManager sharedResources, string helpKeywordPrefix) :
     base(taskInstance)
 {
     this.TaskResources = primaryResources;
     this.TaskSharedResources = sharedResources;
     this.HelpKeywordPrefix = helpKeywordPrefix;
 }

        protected TaskViewModel(ILogger logger, ITask task, string name, string description, object icon)
        {
            if (logger == null)
                throw new ArgumentNullException("logger");
            if (task == null)
                throw new ArgumentNullException("task");
            if (name == null)
                throw new ArgumentNullException("name");
            if (description == null)
                throw new ArgumentNullException("description");
            if (icon == null)
                throw new ArgumentNullException("icon");

            this.logger = logger;
            this.task = task;
            this.name = name;
            this.description = description;
            this.icon = icon;

            task.AddStoppedCallback(() => OnStopped());
            task.AddCancelledCallback(() => OnCancelled());
            task.AddCompletedCallback(() => OnCompleted());
            task.AddErrorCallback(error => OnError(error));
            task.AddFailedCallback(() => OnFailed());
            task.AddPausedCallback(() => OnPaused());
            task.AddProgressCallback(progress => OnProgressChanged(progress));
            task.AddItemChangedCallback(item => OnItemChanged(item));
            task.AddResumedCallback(() => OnResumed());
            task.AddStartedCallback(() => OnStarted());
        }

 internal static string GetV1Path(ITask v1Task)
 {
     var ppszFileName = string.Empty;
     try { ((IPersistFile)v1Task).GetCurFile(out ppszFileName); }
     catch (Exception ex) { throw ex; }
     return ppszFileName;
 }

 private void FillTask(ITask task)
 {
     questionSpelling.Content = task.Question.Spelling;
     questionTranscription.Content = task.Question.Transcription;
     answers.ItemsSource = task.Answers;
     answers.ItemContainerStyleSelector = BuildStyleSelector(false);
 }

 public bool ContainsTask(ITask task)
 {
     if(task.Category is DummyCategory)
         return (task.Category.Name.CompareTo(name) == 0);
     else
         return false;
 }

 public bool ContainsTask(ITask task)
 {
     if(task.Category is RtmCategory)
         return ((task.Category as RtmCategory).ID.CompareTo(ID) == 0);
     else
         return false;
 }

        public void LogTaskState(ITaskExecuteClient client, ITask task, TaskMessage message)
        {
            //��������Լ�¼��־

            if (this.Storage != null)
                this.Storage.SaveTaskChangedState(task, message);
        }

        public IResponse Execute(ITask task)
        {
            Debug.WriteLine(string.Format("{0}: Received task", DateTime.Now));

            bool successful = true;
            Exception exception = null;
            IResult result = null;
            try
            {
                ITaskExecutor taskExecutor = taskExecuterFactory.CreateExecuterFor(task);
                Debug.WriteLine(string.Format("{0}: Executing {1}", DateTime.Now, task.GetType().Name));
                result = taskExecutor.Execute(task);
            }
            catch(Exception e)
            {
                Debug.WriteLine(string.Format("{0}: Error in {1}, {2} ({3})", DateTime.Now, task.GetType().Name, e.GetType().Name, e.Message));
                successful = false;
                exception = e;
                logger.LogException(LogLevel.Debug, "Exception when executing task: " + task.GetType().Name, e);
            }

            var resultType = task.GetType().GetInterfaces().Single(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof (ITask<>)).GetGenericArguments()[0];

            return CreateResponse(resultType, result, successful, exception);
        }

        public TaskContext Execute(ITask task, object associatedData = null)
        {
            var context = new TaskContext(task, associatedData);

            _dispatcher.BeginInvoke(() =>
            {
                _all.Add(task);
                _contexts.Add(context);
                UpdateBusy();
            });


            task.Execute(context).ContinueWith((p, d) =>
            {
                _dispatcher.BeginInvoke(() =>
                {
                    _all.Remove(task);
                    _contexts.Remove(context);
                    UpdateBusy();
                });
            }).Failed((p, d) =>
            {

            });

            return context;
        }

        /// <summary>
        /// This is the same as CompareTo above but should use completion date
        /// instead of due date.  This is used to sort items in the
        /// CompletedTaskGroup.
        /// </summary>
        /// <returns>
        /// whether the task has lower, equal or higher sort order.
        /// </returns>
        public override int Compare(ITask x, ITask y)
        {
            bool isSameDate = true;
            if (x.CompletionDate.Year != y.CompletionDate.Year
                || x.CompletionDate.DayOfYear != y.CompletionDate.DayOfYear)
                isSameDate = false;

            if (!isSameDate) {
                if (x.CompletionDate == DateTime.MinValue) {
                    // No completion date set for some reason.  Since we already
                    // tested to see if the dates were the same above, we know
                    // that the passed-in task has a CompletionDate set, so the
                    // passed-in task should be "higher" in the sort.
                    return 1;
                } else if (y.CompletionDate == DateTime.MinValue) {
                    // "this" task has a completion date and should evaluate
                    // higher than the passed-in task which doesn't have a
                    // completion date.
                    return -1;
                }

                return x.CompletionDate.CompareTo (y.CompletionDate);
            }

            // The completion dates are the same, so no sort based on other
            // things.
            return CompareByPriorityAndName (x, y);
        }

        public TaskDefinitionAssertions AssertExecutableIs(ITask<object> task)
        {
            AssertDefined();
            Assert.That(TaskWithBehaviors.Task, Is.EqualTo(task));

            return this;
        }

        public void Send(ITask task)
        {
            if (!this.running)
                this.Start();

            this.queue.Enqueue(task);
        }

 public void Process(object o, ITask task)
 {
     string path = BasePath + "/" + task.Identify + "/";
     try
     {
         string filename;
         var key = o as IHasKey;
         if (key != null)
         {
             filename = path + key.Key + ".json";
         }
         else
         {
             //check
             filename = path + Encrypt.Md5Encrypt(o.ToString()) + ".json";
         }
         FileInfo file = GetFile(filename);
         using (StreamWriter printWriter = new StreamWriter(file.OpenWrite(), Encoding.UTF8))
         {
             printWriter.WriteLine(JsonConvert.SerializeObject(o));
         }
     }
     catch (Exception e)
     {
         _logger.Warn("write file error", e);
         throw;
     }
 }

 public void QueueTask(ITask task)
 {
     Task newTask = new Task(delegate () {
         task.Execute();
     });
     newTask.RunSynchronously(this);
 }

 public PeriodicalTaskRunner(ITask task, int frequency, DateTime lastRun)
 {
     Task = task;
     _frequency = frequency;
     _lastRun = lastRun;
     _nextRun = _lastRun.AddSeconds(_frequency);
 }

        private static TaskMainDTO TaskMainToTaskMainDTO(ITask param)
        {
            TaskMainDTO target = new TaskMainDTO();

            target.TaskID = param.TaskID;
            target.TargetVersion = param.TargetVersion;
            target.Summary = param.Summary;
            target.SubtaskType = param.SubtaskType;
            target.Status = param.Status;
            target.Project = param.Project;
            target.Product = param.Product;
            target.Priority = param.Priority;
            target.Source = param.Source;
            target.Estimation = param.Estimation;
            target.Description = param.Description;
            target.CreatedDate = param.CreatedDate;
            target.CreatedBy = param.CreatedBy;
            target.Comments = param.Comments;
            target.TokenID = param.TokenID;
            target.LinkToTracker = param.LinkToTracker;

            if (param.TaskParent != null)
            {
                target.TaskParent = TaskMainToTaskMainDTO(param.TaskParent);
            }

            if (param.Assigned != null)
            {
                target.Assigned = UserToUserDTO(param.Assigned);
            }

            return target;
        }

 public void Process(ResultItems resultItems, ITask task)
 {
     foreach (DictionaryEntry entry in resultItems.GetAll())
     {
         System.Console.WriteLine(entry.Key + ":\t" + entry.Value);
     }
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="task"></param>
        /// <param name="pr"></param>
        public override void OnProcess(ITask task, IParseResult pr)
        {
            if (pr.IsSuccess)
            {
                string opera = task.Opera.Name;
                if (StringHelper.Equal(opera, XD1100OperaNames.ReadReal))
                {
                    ProcessReadReal(task, pr);
                }
                else if( StringHelper.Equal ( opera, XD1100OperaNames.ReadStatus ))
                {
                    ProcessReadStatus(task, pr);
                }
                else if (
                    (StringHelper.Equal(opera, XD1100OperaNames.WriteOT)) ||
                    (StringHelper.Equal(opera, XD1100OperaNames.WriteOTMode)) ||
                    (StringHelper.Equal(opera, XD1100OperaNames.OPERA_READ)) ||
                    (StringHelper.Equal(opera, XD1100OperaNames.OPERA_WRITE))
                    )
                {

                }
                else
                {
                    string s = string.Format("not process xd1100 opera '{0}'", opera);
                    throw new NotImplementedException(s);
                }
            }
        }

        public static ITask Else(this ITask task, Func<bool> predicate, ITask elseTask)
        {
            Contract.Requires(task != null);
            Contract.Requires(predicate != null);

            return new TaskBranched(task, elseTask, predicate);
        }