public Task execute()
 {
     TaskList tl = new TaskList ();
     tl.push (cutTask ());
     tl.push (uploadTask ());
     return tl;
 }

        static Scheduler()
        {
            var lockStrategy = new LockStrategy(LockRecursionPolicy.SupportsRecursion);

            ScheduleQueue = new TaskList<ScheduleHistory>(lockStrategy);
            ScheduleInProgress = new TaskList<ScheduleHistory>(lockStrategy);
        }

 ///<summary>Inserts one TaskList into the database.  Returns the new priKey.</summary>
 internal static long Insert(TaskList taskList)
 {
     if(DataConnection.DBtype==DatabaseType.Oracle) {
         taskList.TaskListNum=DbHelper.GetNextOracleKey("tasklist","TaskListNum");
         int loopcount=0;
         while(loopcount<100){
             try {
                 return Insert(taskList,true);
             }
             catch(Oracle.DataAccess.Client.OracleException ex){
                 if(ex.Number==1 && ex.Message.ToLower().Contains("unique constraint") && ex.Message.ToLower().Contains("violated")){
                     taskList.TaskListNum++;
                     loopcount++;
                 }
                 else{
                     throw ex;
                 }
             }
         }
         throw new ApplicationException("Insert failed.  Could not generate primary key.");
     }
     else {
         return Insert(taskList,false);
     }
 }

 public TaskForm(TaskData data, TaskList lists)
 {
     InitializeComponent();
     gTaskData = data;
     gTaskList = lists;
     foreach (var task in lists)
     {
         LogPathComboBox.Items.Add(task.LogPath);
         ProjectPathComboBox.Items.Add(task.ProjectPath);
     }
     NameTextBox.Text = data.Name;
     LogFolderTextBox.Text = data.LogFolder;
     if (data.LogNumber == -1)
     {
         for (int i = 0; i <= lists.Count; i++)
         {
             if (lists.Cast<TaskData>().Count(t => t.LogNumber == i) == 0)
             {
                 LogNumericUpDown.Value = i;
                 break;
             }
         }
     }
     else
     {
         LogNumericUpDown.Value = data.LogNumber;
     }
 }

        private Expander CreateUITasklist(TaskList list, Google.Apis.Tasks.v1.Data.Tasks tasks)
        {
            var expander = new Expander();

            // Add a bold title.
            expander.Header = list.Title;
            expander.FontWeight = FontWeights.Bold;

            // Add the taskItems (if applicable).
            if (tasks.Items != null)
            {
                var container = new StackPanel();
                foreach (CheckBox box in tasks.Items.Select(CreateUITask))
                {
                    container.Children.Add(box);
                }
                expander.Content = container;
            }
            else
            {
                expander.Content = "There are no tasks in this list.";
            }

            return expander;
        }

 public void Execute(ArgumentList arguments, TaskList tasklist, TagList tags, TagFolder folder)
 {
     ILister lister = new Lister();
     if (arguments.GetParameter(arguments.GetLength() - 1) == "--export")
         lister = new HtmlLister();
     lister.ListFiltered(tasklist.FilterTasks(arguments.GetParameter(1)), arguments.GetParameter(1));
 }

            public override void begin(float length, int chapters, int paragraph)
            {
                time_ = 0.0f;
                this.over_ = false;
                GameManager.GetInstance ().road._speed = 0.001f;
                TaskList tl = new TaskList ();

                for (int i = 0; i < _sentence.Length; ++i) {
                    tl.push (new TaskPack(talkTask(_sentence[i])));
                }
                for (int i = 0; i < _talk.Length; ++i) {

                    if(_close[i]){
                        tl.push (_talk[i].goOutTask ());
                    }else{
                        tl.push (_talk[i].closePopTask ());

                    }
                }
                TaskManager.PushBack (tl, delegate {
                    this.over_ = true;
                    GameManager.GetInstance ().road._speed = 1.0f;
                });
                TaskManager.Run (tl);
            }

        public AddTasksListViewModel(Func<TaskList, AddTasksList> addTasksListsFactory)
        {
            base.DisplayName = WindowTitle;

            _task = new TaskList();
            _addTasksListsFactory = addTasksListsFactory;
        }

 public FixDeleteAction(TaskManagerNoteAddin addin, TaskList tasklist1, TaskList tasklist2, int line)
     : base(addin)
 {
     Priority = false;
     this.tasklist1 = tasklist1;
     this.tasklist2 = tasklist2;
     this.line = line;
 }

        public async Task TaskGenerateAsync(int count)
        {
            var connect = new SQLiteAsyncConnection(DataBaseFile);
			var taskList = await connect.Table<TaskTable>().Take(count).ToListAsync();
			taskList.Shuffle ();
            var categoryList = await connect.Table<CategoryTable>().ToListAsync();
            _tasks = new TaskList(taskList, categoryList);
        }

 // Use this for initialization
 void Start()
 {
     TaskList tl = new TaskList ();
     for(int i = 0;i<_sentence.Length; ++i){
         tl.push (_talk.popTask (_sentence[i]));
     }
     TaskManager.Run (tl);
 }

 public static void Main(string[] args)
 {
     var console = new RealConsole();
     var projectRepository = new ProjectRepository();
     var taskRepository = new TaskRepository();
     var taskList = new TaskList(console, projectRepository, taskRepository);
     taskList.Run();
 }

 public void Execute(ArgumentList arguments, TaskList tasklist, TagList tags, TagFolder folder)
 {
     FileIO loader = new FileIO();
     if (tasklist.MarkAsDone(arguments.GetParameter(1)))
     loader.SaveTasks(tasklist.GetTasks());
         else
             Console.WriteLine("No task with that id found to mark as done");
 }

 public void Execute(ArgumentList arguments, TaskList tasks, TagList tags, TagFolder folder)
 {
     FileIO loader = new FileIO();
     TaskTagger tagTasks = new TaskTagger(tasks.GetTasks());
     if (tagTasks.Untag(arguments.GetParameter(1), arguments.GetParameter(2)))
         loader.SaveTasks(tagTasks.GetTasks());
     else
         Console.WriteLine("No task with that id found to untag");
 }

		public void SelectMany()
		{
			string tempTaskFile = CreateTempTasksFile();
			var tl = new TaskList(tempTaskFile);
			IOrderedEnumerable<string> contexts = tl.SelectMany(task => task.Contexts,
			                                                    (task, context) => context).Distinct().OrderBy(context => context);

			Assert.AreEqual(3, contexts.Count());
		}

        public Task(string taskText, string creator, int taskId, TaskList parentTaskList)
        {
            Creator = creator;
            TaskText = taskText;
            TaskId = taskId;
            ParentTaskList = parentTaskList;

            UpdateStatus(parentTaskList.DefaultStatus);
        }

        public void visit(TaskList list)
        {
            DataClassesDataContext local = new DataClassesDataContext();

            Lists newList = new Lists();
            newList.Title = list.Name;
            /*newList.Description = list.description;
            newList.CreationDate = DateTime.Now;*/
        }

 public EditTasksList(
     TaskList tasksList, 
     TasksService tasksService, 
     IBusyIndicator busyIndicator, 
     DataContext dataContext)
 {
     _tasksList = tasksList;
     _tasksService = tasksService;
     _busyIndicator = busyIndicator;
     _dataContext = dataContext;
 }

 public void Execute(ArgumentList arguments, TaskList tasklist, TagList tags, TagFolder folder)
 {
     FileIO loader = new FileIO();
     if (tasklist.RemoveTask(arguments.GetParameter(1)))
         {
         loader.SaveTasks(tasklist.GetTasks());
         Console.WriteLine("Task " + arguments.GetParameter(1) + " removed.");
         }
     else
     Console.WriteLine("No task with that id found to remove");
 }

 public void Given()
 {
     _taskList = new TaskList<string>();
     _container = new DefaultKernel();
     ServiceLocator<string>.SetInstance(_container);
     _container.Register(Component.For<TaskList<string>>().Instance(_taskList));
     _container.Register(Component.For<SequentialBuilder<string>>().Instance(new SequentialBuilder<string>(_taskList)));
     _container.Register(Component.For<WorkflowEngine<string>>().Instance(new WorkflowEngine<string>()));
     _workflow = new Workflow<string>();
     _function = new Func<bool>(RedOrangeYellow);
 }