Пример #1
0
        /// <summary>
        /// Cleans up after a task.
        /// </summary>
        /// <param name="mgr">The task manager.</param>
        private void CleanupAfterTask(TaskWorkerManager mgr)
        {
            mgr.TasksCancelled -= mgr_TasksCancelled;
            mgr.TasksCompleted -= mgr_TasksCompleted;
            mgr.TasksFailed    -= mgr_TasksFailed;
            TaskWorker dummy;

            CurrentTasks.TryRemove(mgr.CurrentTask, out dummy);
            completed.Add(mgr.CurrentTask);
            managers.TryRemove(mgr, out mgr);
        }
Пример #2
0
        /// <summary>
        /// Runs the tasks.
        /// </summary>
        private void RunTasks()
        {
            if (completed.Count == Tasks.Count)
            {
                TasksCompleted.RaiseEvent(this);
                return;
            }
            lock (CurrentTasks)
            {
                IEnumerable <TaskWorker> available = Dependancies.GetAvailable(Tasks, Completed);
                available = available.Except(CurrentTasks.Keys);

                foreach (TaskWorker worker in available)
                {
                    List <TaskWorker> ensureNotRunning = new List <TaskWorker>();
                    //Check if we have a key saying that this cannot be run at the same time as...
                    if (PreventSimultaneousRunning.Dependancies.ContainsKey(worker))
                    {
                        ensureNotRunning = PreventSimultaneousRunning.Dependancies[worker].DependsOn.ToList();
                    }

                    //Then see if anything says x is not allowed to be run at the same time as this
                    IEnumerable <Dependacy <TaskWorker> > dependancies = PreventSimultaneousRunning.Dependancies.Where(d => d.Value.DependsOn.Contains(worker)).Select(kvp => kvp.Value);
                    ensureNotRunning.AddRange(dependancies.Select(depend =>
                    {
                        List <TaskWorker> items = new List <TaskWorker>();
                        items.Add(depend.Item);
                        return(items);
                    }).SelectMany(i => i));

                    if (CurrentTasks.Any(t => ensureNotRunning.Contains(t.Value)))
                    {
                        continue;
                    }

                    CurrentTasks.TryAdd(worker, worker);
                    TaskWorkerManager mgr = new TaskWorkerManager(worker);
                    mgr.AutoTryRecover  = AutoTryRecover;
                    mgr.TasksCancelled += mgr_TasksCancelled;
                    mgr.TasksCompleted += mgr_TasksCompleted;
                    mgr.TasksFailed    += mgr_TasksFailed;
                    managers.TryAdd(mgr, mgr);
                    mgr.Start();
                }
            }
        }
        /// <summary>
        /// Runs the tasks.
        /// </summary>
        private void RunTasks()
        {
            if (completed.Count == Tasks.Count)
            {
                TasksCompleted.RaiseEvent(this);
                return;
            }
            lock (CurrentTasks)
            {
                IEnumerable<TaskWorker> available = Dependancies.GetAvailable(Tasks, Completed);
                available = available.Except(CurrentTasks.Keys);

                foreach (TaskWorker worker in available)
                {
                    List<TaskWorker> ensureNotRunning = new List<TaskWorker>();
                    //Check if we have a key saying that this cannot be run at the same time as...
                    if (PreventSimultaneousRunning.Dependancies.ContainsKey(worker))
                    {
                        ensureNotRunning = PreventSimultaneousRunning.Dependancies[worker].DependsOn.ToList();
                    }

                    //Then see if anything says x is not allowed to be run at the same time as this
                    IEnumerable<Dependacy<TaskWorker>> dependancies = PreventSimultaneousRunning.Dependancies.Where(d => d.Value.DependsOn.Contains(worker)).Select(kvp => kvp.Value);
                    ensureNotRunning.AddRange(dependancies.Select(depend =>
                    {
                        List<TaskWorker> items = new List<TaskWorker>();
                        items.Add(depend.Item);
                        return items;
                    }).SelectMany(i => i));

                    if (CurrentTasks.Any(t => ensureNotRunning.Contains(t.Value)))
                    {
                        continue;
                    }

                    CurrentTasks.TryAdd(worker, worker);
                    TaskWorkerManager mgr = new TaskWorkerManager(worker);
                    mgr.AutoTryRecover = AutoTryRecover;
                    mgr.TasksCancelled += mgr_TasksCancelled;
                    mgr.TasksCompleted += mgr_TasksCompleted;
                    mgr.TasksFailed += mgr_TasksFailed;
                    managers.TryAdd(mgr, mgr);
                    mgr.Start();
                }
            }
        }
 /// <summary>
 /// Cleans up after a task.
 /// </summary>
 /// <param name="mgr">The task manager.</param>
 private void CleanupAfterTask(TaskWorkerManager mgr)
 {
     mgr.TasksCancelled -= mgr_TasksCancelled;
     mgr.TasksCompleted -= mgr_TasksCompleted;
     mgr.TasksFailed -= mgr_TasksFailed;
     TaskWorker dummy;
     CurrentTasks.TryRemove(mgr.CurrentTask, out dummy);
     completed.Add(mgr.CurrentTask);
     managers.TryRemove(mgr, out mgr);
 }