NopCommerce之任务执行

NOP任务提供两种：手动执行（立即）和定时执行两种。

首先来说下手动任务执行过程，下图是NOP定时任务管理界面：

从上面可以看出，我们可以选择具体的任务来手动执行任务（立即执行），当点击【立即执行】按钮时会触发以下事件：

1、获取ScheduleTask对象（从数据库或缓存中）

2、创建Task对象，传入ScheduleTask对象作为构造参数，并为Task对象字段赋值

3、执行Task里的Execute（）方法，该方法主要负责ITask实现类的创建，并执行Execute（）方法，完成对任务的执行。

具体代码如下：

   public ActionResult RunNow(int id)
         {
             if (!_permissionService.Authorize(StandardPermissionProvider.ManageScheduleTasks))
                 return AccessDeniedView();

             try
             {
                 var scheduleTask = _scheduleTaskService.GetTaskById(id);
                 if (scheduleTask == null)
                     throw new Exception("Schedule task cannot be loaded");

                 var task = new Task(scheduleTask);
                 //ensure that the task is enabled
                 task.Enabled = true;
                 //do not dispose. otherwise, we can get exception that DbContext is disposed
                 task.Execute(true, false);
                 SuccessNotification(_localizationService.GetResource("Admin.System.ScheduleTasks.RunNow.Done"));
             }
             catch (Exception exc)
             {
                 ErrorNotification(exc);
             }

             return RedirectToAction("List");
         }

第8行：获取ScheduleTask对象（从数据库或缓存中）

第16行：、创建Task对象，传入ScheduleTask对象作为构造参数，并为Task对象字段赋值，然后我们进入到该方法体内看下

  public void Execute(bool throwException = false, bool dispose = true)
         {
             this.IsRunning = true;

             //background tasks has an issue with Autofac
             //because scope is generated each time it's requested
             //that's why we get one single scope here
             //this way we can also dispose resources once a task is completed
             var scope = EngineContext.Current.ContainerManager.Scope();
             var scheduleTaskService = EngineContext.Current.ContainerManager.Resolve<IScheduleTaskService>("", scope);
             var scheduleTask = scheduleTaskService.GetTaskByType(this.Type);

             try
             {
                 var task = this.CreateTask(scope);
                 if (task != null)
                 {
                     this.LastStartUtc = DateTime.UtcNow;
                     if (scheduleTask != null)
                     {
                         //update appropriate datetime properties
                         scheduleTask.LastStartUtc = this.LastStartUtc;
                         scheduleTaskService.UpdateTask(scheduleTask);
                     }

                     //execute task
                     task.Execute();
                     this.LastEndUtc = this.LastSuccessUtc = DateTime.UtcNow;
                 }
             }
             catch (Exception exc)
             {
                 this.Enabled = !this.StopOnError;
                 this.LastEndUtc = DateTime.UtcNow;

                 //log error
                 var logger = EngineContext.Current.ContainerManager.Resolve<ILogger>("", scope);
                 logger.Error(string.Format("Error while running the '{0}' schedule task. {1}", this.Name, exc.Message), exc);
                 if (throwException)
                     throw;
             }

             if (scheduleTask != null)
             {
                 //update appropriate datetime properties
                 scheduleTask.LastEndUtc = this.LastEndUtc;
                 scheduleTask.LastSuccessUtc = this.LastSuccessUtc;
                 scheduleTaskService.UpdateTask(scheduleTask);
             }

             //dispose all resources
             if (dispose)
             {
                 scope.Dispose();
             }

             this.IsRunning = false;
         }

第15行：ITask实现类的创建，里面可能包括反射、关联对象的一些创建

第27行：执行实现了ITask类的Execute（）方法，完成对任务的执行。最后更新字段。

二、第二种就是定时任务了，相对来说复杂点。

首先、在项目启动时的Application_Start（）方法里，我们创建了任务管理类，

     protected void Application_Start()
         {

             //start scheduled tasks
             if (databaseInstalled)
             {
                 TaskManager.Instance.Initialize();
                 TaskManager.Instance.Start();
             }
 }

该类主要负责任务的初始化，添加到线程列表，任务的开始和停止，如下：

  /// <summary>
         /// Initializes the task manager with the property values specified in the configuration file.
         /// </summary>
         public void Initialize()
         {
             this._taskThreads.Clear();

             var taskService = EngineContext.Current.Resolve<IScheduleTaskService>();
             var scheduleTasks = taskService
                 .GetAllTasks()
                 .OrderBy(x => x.Seconds)
                 .ToList();

             //group by threads with the same seconds
             foreach (var scheduleTaskGrouped in scheduleTasks.GroupBy(x => x.Seconds))
             {
                 //create a thread
                 var taskThread = new TaskThread
                                      {
                                          Seconds = scheduleTaskGrouped.Key
                                      };
                 foreach (var scheduleTask in scheduleTaskGrouped)
                 {
                     var task = new Task(scheduleTask);
                     taskThread.AddTask(task);
                 }
                 this._taskThreads.Add(taskThread);
             }

             //sometimes a task period could be set to several hours (or even days).
             //in this case a probability that it'll be run is quite small (an application could be restarted)
             //we should manually run the tasks which weren't run for a long time
             var notRunTasks = scheduleTasks
                 //find tasks with "run period" more than 30 minutes
                 .Where(x => x.Seconds >= _notRunTasksInterval)
                 .Where(x => !x.LastStartUtc.HasValue || x.LastStartUtc.Value.AddSeconds(x.Seconds) < DateTime.UtcNow)
                 .ToList();
             //create a thread for the tasks which weren't run for a long time
             if (notRunTasks.Count > )
             {
                 var taskThread = new TaskThread
                 {
                     RunOnlyOnce = true,
                     Seconds =  *  //let's run such tasks in 5 minutes after application start
                 };
                 foreach (var scheduleTask in notRunTasks)
                 {
                     var task = new Task(scheduleTask);
                     taskThread.AddTask(task);
                 }
                 this._taskThreads.Add(taskThread);
             }
         }

代码分析如下：

1、清空任务线程，

2、获取数据库内所有的任务

3、创建任务线程对象

4、创建Task对象

5、将Task对象存入 Dictionary<string, Task> 包装的集合中

6、最后将线程对象taskThread存入到 由List<TaskThread>包装集合中，该集合保存了所有任务的线程，

上面执行我们将所有需要执行的任务存入到List<TaskThread>包装集合中集合，我们下面就可以针对这些任务，执行定时任务，我们看下TaskManager类中Start（）方法是如何写的：

        public void Start()
         {
             foreach (var taskThread in this._taskThreads)
             {
                 taskThread.InitTimer();
             }
         }

上面的代码可以看出，NOP是循环线程集合中所有任务，并执行定时任务的。

   public void InitTimer()
         {
             if (this._timer == null)
             {
                 this._timer = new Timer(new TimerCallback(this.TimerHandler), null, this.Interval, this.Interval);
             }
         }

上面的代码创建了Timer对象，在定时的时间内会执行TimerHandler()方法体中内容，方法体里的内容如下：

   private void TimerHandler(object state)
         {
             this._timer.Change(-, -);
             this.Run();
             if (this.RunOnlyOnce)
             {
                 this.Dispose();
             }
             else
             {
                 this._timer.Change(this.Interval, this.Interval);
             }
         }

在方法体中会有个Run()方法，该方法会执行当前任务类中的Execute（）方法，代码如下：

    private void Run()
         {
             if (Seconds <= )
                 return;

             this.StartedUtc = DateTime.UtcNow;
             this.IsRunning = true;
             foreach (Task task in this._tasks.Values)
             {
                 task.Execute();
             }
             this.IsRunning = false;
         }

这样就实现了定时执行任务功能。。。

由于很少写博客，并且功力有限。只能这样了。。。欢迎指正