C# TaskService.FindTask方法代码示例

 public static void AddStores2TaskScheduler(string strStoresPath, string strActionPath)
 {
     string[] strXMLFiles = Directory.GetFiles(strStoresPath, "*.xml");
     TaskService ts = new TaskService();
     Console.ForegroundColor = ConsoleColor.Cyan;
     Console.WriteLine("");
     Console.WriteLine("Adding stores to the Task Scheduler");
     Console.ForegroundColor = ConsoleColor.Green;
     foreach (string strXMLFile in strXMLFiles)
     {
         string storeName = Path.GetFileName(strXMLFile);
         string taskName = @"BC Store " + storeName;
         Task t = ts.FindTask(taskName);
         if (t == null)
         {
             Console.WriteLine("  + " + storeName);
             DailyTrigger dt = new DailyTrigger();
             dt.StartBoundary = DateTime.Today.Date;
             dt.Repetition.Duration = TimeSpan.FromMinutes(1430);
             dt.Repetition.Interval = TimeSpan.FromMinutes(2);
             ts.AddTask(taskName, dt, new ExecAction(strActionPath, strXMLFile, null));
             Thread.Sleep(500);
         }
     }
     Console.ForegroundColor = ConsoleColor.Cyan;
     Console.WriteLine("All stores added");
     Console.WriteLine("");
     Console.WriteLine("");
     Console.ForegroundColor = ConsoleColor.White;
 }

 internal static void FindTask(TaskService ts, System.IO.TextWriter output, params string[] arg)
 {
     try
     {
         Task t = ts.FindTask(arg[0]);
         if (t == null)
             output.WriteLine(string.Format("Task '{0}' not found.", arg[0]));
         else
         {
             output.WriteLine(string.Format("Task '{0}' found. Created on {1:g} and last run on {2:g}.", t.Name, t.Definition.RegistrationInfo.Date, t.LastRunTime));
             if (t.Definition.Triggers.ContainsType(typeof(CustomTrigger)))
             {
                 foreach (var tr in t.Definition.Triggers)
                 {
                     CustomTrigger ct = tr as CustomTrigger;
                     if (ct != null && ct.Properties.Count > 0)
                     {
                         output.WriteLine("Custom Trigger Properties:");
                         int i = 0;
                         foreach (var name in ct.Properties.Names)
                             output.WriteLine("{0}. {1} = {2}", ++i, name, ct.Properties[name]);
                     }
                 }
             }
         }
     }
     catch (Exception ex)
     {
         output.WriteLine(ex.ToString());
     }
 }

		void SaveTask()
		{
			bool isNewTask = true;
			try
			{
				var service = new TaskService();
				TaskDefinition td = service.NewTask();
				Microsoft.Win32.TaskScheduler.TriggerCollection trgCollection;
				var oldTriggerDate = new DateTime();

				Task task = service.FindTask(MainWindowViewModel.FreemiumDriverScanTaskName);

				if (task != null)
				{
					isNewTask = false;
					oldTriggerDate = task.Definition.Triggers.Count > 0 ? task.Definition.Triggers[0].StartBoundary.Date : DateTime.Today;
					task.Definition.Triggers.Clear();
					trgCollection = task.Definition.Triggers;
				}
				else
				{
					td.RegistrationInfo.Description = WPFLocalizeExtensionHelpers.GetUIString("WindowsTaskRegistrationInfo");
					td.Settings.Enabled = true;
					td.Actions.Add(new ExecAction(Environment.CurrentDirectory + @"\1Click.exe"));
					trgCollection = td.Triggers;
				}

				TimeSpan selectedTime = TimeSpan.Parse(((ComboBoxItem)AutoScanTime.SelectedValue).Content.ToString());
				switch (AutoScanPeriod.SelectedIndex)
				{
					case (int)Schedule.Daily:
						{
							var dTrigger = new DailyTrigger {DaysInterval = 1};
							if (isNewTask)
								dTrigger.StartBoundary = DateTime.Today.Date + selectedTime;
							else
								dTrigger.StartBoundary = oldTriggerDate + selectedTime;

							trgCollection.Add(dTrigger);
							break;
						}
					case (int)Schedule.Weekly:
						{
							var wTrigger = new WeeklyTrigger();
							switch (AutoScanDay.SelectedIndex)
							{
								case (int)DayOfWeek.Monday:
									{
										wTrigger.DaysOfWeek = DaysOfTheWeek.Monday;
										break;
									}
								case (int)DayOfWeek.Tuesday:
									{
										wTrigger.DaysOfWeek = DaysOfTheWeek.Tuesday;
										break;
									}
								case (int)DayOfWeek.Wednesday:
									{
										wTrigger.DaysOfWeek = DaysOfTheWeek.Wednesday;
										break;
									}
								case (int)DayOfWeek.Thursday:
									{
										wTrigger.DaysOfWeek = DaysOfTheWeek.Thursday;
										break;
									}
								case (int)DayOfWeek.Friday:
									{
										wTrigger.DaysOfWeek = DaysOfTheWeek.Friday;
										break;
									}
								case (int)DayOfWeek.Saturday:
									{
										wTrigger.DaysOfWeek = DaysOfTheWeek.Saturday;
										break;
									}
								case (int)DayOfWeek.Sunday:
									{
										wTrigger.DaysOfWeek = DaysOfTheWeek.Sunday;
										break;
									}
							}
							trgCollection.Add(wTrigger);
							foreach (WeeklyTrigger trg in trgCollection)
							{
								if (isNewTask)
									trg.StartBoundary = DateTime.Today.Date + selectedTime;
								else
									trg.StartBoundary = oldTriggerDate + selectedTime;
								trg.WeeksInterval = 1;
							}
							break;
						}
					case (int)Schedule.Monthly:
						{
							var mTrigger = new MonthlyTrigger();
							if (isNewTask)
								mTrigger.StartBoundary = DateTime.Today.Date + selectedTime;
							else
								mTrigger.StartBoundary = oldTriggerDate + selectedTime;
//.........这里部分代码省略.........

		public bool CreateOrActivate(String TaskName, String FullExecuteableFileName, TimeSpan RetryIntervall)
			{
			//if (!IsAdministrator())
			//	return false;
			using (TaskService taskService = new TaskService())
				{
				Task task = taskService.FindTask(TaskName);
				if (task == null)
					{
					TaskDefinition taskDefinition = CreateTask(taskService, TaskName, RetryIntervall);
					taskDefinition.Actions.Add(new ExecAction(FullExecuteableFileName));
					
					taskDefinition.RegistrationInfo.Description = $"WPMedia created Task for " +
									$"{Path.GetFileNameWithoutExtension(FullExecuteableFileName)}";
					taskDefinition.Settings.MultipleInstances = TaskInstancesPolicy.IgnoreNew;
					taskDefinition.Settings.AllowDemandStart = true;
					taskDefinition.Settings.AllowHardTerminate = false;
					taskDefinition.Settings.DisallowStartIfOnBatteries = false;
					taskDefinition.RegistrationInfo.Author = "WPMediaAutoRegistration";
					if (taskDefinition.Validate())
						task = taskService.RootFolder.RegisterTaskDefinition(TaskName, taskDefinition);
					else
						throw new Exception($"{TaskName} Scheduling for {FullExecuteableFileName} failed");
					}
				task.Enabled = true;
				}
			return true;
			}

 public static bool StartupTaskExists()
 {
     using (TaskService _taskService = new TaskService())
     {
         return _taskService.FindTask(_taskName) != null;
     }
 }

 public void clearSchedules()
 {
     string strTaskID = "";
     try
     {
         // Get the service on the local machine
         TaskService ts = new TaskService();
         // Delete Schedules
         DataTable dt = this.GetSchedules(1);
         foreach (DataRow dr in dt.Rows)
         {
             strTaskID = dr["TaskID"].ToString();
             if (ts.FindTask(strTaskID, true) != null)
             {
                 // Remove the task we just created
                 ts.RootFolder.DeleteTask(strTaskID);
             }
             // Delete schedules follow taskid
             this.DeleleSchedules(strTaskID);
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }

        public static bool PersistTask(bool startAtLogon, bool startForAllUsers)
        {
            WinTasks.TaskService ts = new WinTasks.TaskService();
            try
            {
                WindowsIdentity currentIdentity = WindowsIdentity.GetCurrent();
                bool isElevated = (new WindowsPrincipal(currentIdentity).IsInRole(WindowsBuiltInRole.Administrator));
                WinTasks.Task task = ts.FindTask(Application.ProductName, false);

                if (startAtLogon)
                {
                    if (startForAllUsers && !isElevated)
                    {
                        return PersistTaskElevated(startAtLogon, startForAllUsers);
                    }
                    else
                    {
                        WinTasks.LogonTrigger trigger = (WinTasks.LogonTrigger)WinTasks.LogonTrigger.CreateTrigger(WinTasks.TaskTriggerType.Logon);
                        trigger.Enabled = true;
                        trigger.StartBoundary = DateTime.Today;
                        if (startForAllUsers)
                            trigger.UserId = null;
                        else
                            trigger.UserId = currentIdentity.Name;

                        WinTasks.ExecAction action = (WinTasks.ExecAction)WinTasks.ExecAction.CreateAction(WinTasks.TaskActionType.Execute);
                        action.Path = Application.ExecutablePath;
                        action.WorkingDirectory = System.IO.Path.GetDirectoryName(Application.ExecutablePath);

                        if (task == null)
                        {
                            task = ts.AddTask(Application.ProductName, trigger, action, currentIdentity.Name);
                        }
                        else
                        {
                            task.Definition.Triggers.Clear();
                            task.Definition.Triggers.Add(trigger);
                            task.Definition.Actions.Clear();
                            task.Definition.Actions.Add(action);
                            task.RegisterChanges();
                        }
                    }
                }
                else if (task != null)
                {
                    ts.GetFolder("\\").DeleteTask(task.Name);
                }
            }
            catch
            {
                return false;
            }
            finally
            {
                ts.Dispose();
            }
            return true;
        }

        private void btnInput_Click(object sender, EventArgs e)
        {
            string strTaskID = "";
            string appPath = System.Configuration.ConfigurationManager.AppSettings["AutoGetOdds"];
            Application.DoEvents();
            Cursor.Current = Cursors.WaitCursor;

            try
            {
                // Get the service on the local machine
                TaskService ts = new TaskService();
                // Delete Schedules
                DataTable dt = oddBO.GetSchedules(1);
                foreach (DataRow dr in dt.Rows)
                {
                    strTaskID = dr["TaskID"].ToString();
                    if (ts.FindTask(strTaskID, true) != null)
                    {
                        // Remove the task we just created
                        ts.RootFolder.DeleteTask(strTaskID);
                    }
                    // Delete schedules follow taskid
                    oddBO.DeleleSchedules(strTaskID);
                }
                DateTime currDate = dtpDate.Value;
                // Create Schedules
                dt = oddBO.GetSchedules(0, currDate);
                foreach (DataRow dr in dt.Rows)
                {
                    strTaskID = dr["TaskID"].ToString();
                    // Create a new task definition and assign properties
                    TaskDefinition td = ts.NewTask();

                    Trigger t = new TimeTrigger();
                    t.StartBoundary = Convert.ToDateTime(dr["RunTime"].ToString());

                    td.RegistrationInfo.Description = "Get odd at " + dr["RunTime"].ToString();

                    // Create a trigger that will fire the task at this time every other day
                    td.Triggers.Add(t);

                    // Create an action that will launch Notepad whenever the trigger fires
                    td.Actions.Add(new ExecAction(appPath, "\"" + strTaskID + "\"", null));

                    // Register the task in the root folder
                    ts.RootFolder.RegisterTaskDefinition(strTaskID, td);
                }
                MessageBox.Show("Schedules have inputed successfully!", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            finally
            {
                Cursor.Current = Cursors.WaitCursor;
            }
        }

        /// <summary>
        /// Gets task by its name
        /// </summary>
        /// <param name="taskName">task name</param>
        /// <returns></returns>
        public static Task GetTaskByName(string taskName)
        {
            Task task = null;
            try
            {
                TaskService service = new TaskService();
                task = service.FindTask(taskName, true);

            }
            catch { }

            return task;
        }

        public static void DeleteTask(string taskName)
        {
            Task task = null;
            try
            {
                TaskService service = new TaskService();
                task = service.FindTask(taskName, true);

                if (task != null)
                    service.RootFolder.DeleteTask(taskName);
            }
            catch { }
        }

        public void UnScheduleBackup()
        {
            // Get the service on the local machine
            using (var ts = new TaskService())
            {
                Task existingTask = ts.FindTask("EC2 Backup");

                if (null != existingTask)
                {
                    // Remove the task we just created
                    ts.RootFolder.DeleteTask(existingTask.Name);
                }
            }
        }

        public static void UpdateTaskStatus(string taskName, bool isEnabled)
        {
            try
            {
                TaskService service = new TaskService();
                Task task = service.FindTask(taskName, true);

                if (task != null)
                {
                    task.Enabled = isEnabled;
                    task.RegisterChanges();
                }
            }
            catch{}
        }

		public bool Disable(String TaskName)
			{
			if (!IsAdministrator())
				return false;

			using (TaskService taskService = new TaskService())
				{
				Task task = taskService.FindTask(TaskName);
				if (task == null)
					{
					return false;
					}
				task.Enabled = false;
				return true;
				}
			}

        public SkylineNightly()
        {
            InitializeComponent();
            startTime.Value = DateTime.Parse(Settings.Default.StartTime);
            textBoxFolder.Text = Settings.Default.NightlyFolder;
            includePerfTests.Checked = Settings.Default.PerfTests;
            if (string.IsNullOrEmpty(textBoxFolder.Text))
                textBoxFolder.Text = Path.Combine(
                    Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
                    "SkylineNightly"); // Not L10N

            using (var ts = new TaskService())
            {
                var task = ts.FindTask(Nightly.NIGHTLY_TASK_NAME);
                enabled.Checked = (task != null);
            }
        }

        public static void Start(string command)
        {
            using (var ts = new TaskService())
            {
                var td = ts.NewTask();
                td.RegistrationInfo.Description = "start " + taskName + " limited user";
                td.Actions.Add(new ExecAction(command));
                td.Settings.Priority = ProcessPriorityClass.Normal;
                td.Principal.RunLevel = TaskRunLevel.LUA;
                td.Settings.AllowDemandStart = true;
                td.Settings.DisallowStartIfOnBatteries = false;
                td.Settings.StopIfGoingOnBatteries = false;

                var ret = ts.RootFolder.RegisterTaskDefinition(taskName, td);

                var fooTask = ts.FindTask(taskName, true);
                fooTask.Run();

                ts.RootFolder.DeleteTask(taskName);
            }
        }