/// <summary>
/// Изменить состояние задачи в Windows Task Scheduler.
/// </summary>
/// <param name="taskName"> название задачи </param>
/// <param name="isStart"> запустить, если true, остановить, если false </param>
/// <returns> результат выполнения </returns>
public static ActionResult ChangeTaskState(string taskName, bool isStart)
{
string msg = "";
bool isSuccessful = false;
try
{
ITaskService ts = new TaskSchedulerClass();
ts.Connect("localhost");
ITaskFolder taskFolder = ts.GetFolder("\\");
IRegisteredTask task = taskFolder.GetTask(taskName);
if (isStart)
{
task.Run(null);
}
else
{
task.Stop(0);
task.Enabled = false;
}
isSuccessful = true;
}
catch (Exception e)
{
msg = e.Message;
}
return(new ActionResult(isSuccessful, msg));
}
/// <summary>
/// Converts the Scheduled Task COM representation to Business Entity
/// </summary>
/// <param name="task">COM Scheduled Task</param>
/// <returns>An instance of Scheduled Task</returns>
private static ScheduledTask TransformToTask(IRegisteredTask task)
{
ScheduledTask scheduledTask = new ScheduledTask();
scheduledTask.Name = task.Name;
scheduledTask.CurrentState = task.State.ToString();
scheduledTask.TaskPath = task.Path;
scheduledTask.NextRunTime = task.NextRunTime;
scheduledTask.LastRunTime = task.LastRunTime;
scheduledTask.LastRunResults = task.LastTaskResult.ToString();
ITaskDefinition definition = task.Definition;
ITaskSettings settings = definition.Settings;
scheduledTask.Priority = settings.Priority;
scheduledTask.Settings = new Settings();
scheduledTask.Settings.Enabled = settings.Enabled;
scheduledTask.Settings.Hidden = settings.Hidden;
IRegistrationInfo registrationInfo = definition.RegistrationInfo;
scheduledTask.Description = registrationInfo.Description;
scheduledTask.Author = registrationInfo.Author;
return(scheduledTask);
}
// Install the UAC bypass CosmosTask. This must be performed while the program is running under
// administrator credentials with elevation.
void InstallScheduledTask()
{
ITaskService xService = new TaskScheduler.TaskScheduler();
xService.Connect();
ITaskFolder xFolder = xService.GetFolder(@"\");
IRegisteredTask xTask = TryGetInstallScheduledTask(xFolder);
if (null != xTask)
{
// The first parameter MUST NOT be prefixed with the folder path.
xFolder.DeleteTask(InstallScheduledTaskName, 0);
}
ITaskDefinition xTaskDef = xService.NewTask(0);
xTaskDef.RegistrationInfo.Description = "Cosmos DevKit UAC Bypass";
xTaskDef.RegistrationInfo.Author = "Cosmos Group";
xTaskDef.Settings.Compatibility = _TASK_COMPATIBILITY.TASK_COMPATIBILITY_V2_1;
xTaskDef.Settings.DisallowStartIfOnBatteries = false;
xTaskDef.Principal.RunLevel = _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST;
IActionCollection xActions = xTaskDef.Actions;
IAction xAction = xActions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
IExecAction xExecAction = xAction as IExecAction;
xExecAction.Path = mSetupPath;
xExecAction.Arguments = @"/SILENT";
// 6 = task can be created or updated ["CreateOrUpdate" flag]
// if Name id empty or null, System will create a task with name as GUID
xTask = xFolder.RegisterTaskDefinition(InstallScheduledTaskName, xTaskDef, 6, null, null, _TASK_LOGON_TYPE.TASK_LOGON_NONE, null);
}
static void Main()
{
String instDir = Environment.GetEnvironmentVariable("PROGRAMFILES") + "\\win7bel\\";
try
{
TaskSchedulerClass ts = new TaskSchedulerClass();
ts.Connect(null, null, null, null);
ITaskFolder root = ts.GetFolder("\\");
ITaskDefinition task = ts.NewTask(0);
task.Settings.RunOnlyIfNetworkAvailable = true;
task.Settings.StartWhenAvailable = true;
IDailyTrigger trigger = (IDailyTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_DAILY);
trigger.StartBoundary = "2011-01-01T15:00:00";
IExecAction exec = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
exec.Id = "win7bel-updater";
exec.Path = instDir + "win7bel-updater.exe";
IRegisteredTask regTask = root.RegisterTaskDefinition("win7bel-updater", task, (int)_TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null, _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN, "");
}
catch (Exception ex)
{
MessageBox.Show("Памылка ўсталёўкі спраўджвання абнаўленняў перакладу Windows 7\nПаведаміце, калі ласка, на [email protected] :\n" + ex.Message, "Памылка", MessageBoxButtons.OK, MessageBoxIcon.Error);
Environment.Exit(1);
}
Environment.Exit(0);
}
private void ActionOnTask(IRegisteredTask rt)
{
Count++;
if (!scoreFlag)
{
var task = Deserialize(rt.Xml);
if (task.Actions.Exec is null)
{
TaskInfoData.Add(
new TaskData
{
Path = rt.Path,
Name = rt.Name,
Type = TaskType.Scheduler,
IsSigned = false
});
}
else
{
TaskInfoData.Add(
new TaskData
{
Path = task.Actions.Exec.Command,
Name = rt.Name,
Type = TaskType.Scheduler,
IsSigned = base.VerifyAuthenticodeSignature(task.Actions.Exec.Command)
});
}
}
}
private void btnCreateTask_Click(object sender, EventArgs e)
{
try
{
objScheduler = new TaskScheduler();
objScheduler.Connect();
//Setting Task Definition
SetTaskDefinition();
//Setting Task Trigger Information
SetTriggerInfo();
//Setting Task Action Information
SetActionInfo();
//Getting the roort folder
ITaskFolder root = objScheduler.GetFolder("\\");
//Registering the task, if the task is already exist then it will be updated
IRegisteredTask regTask = root.RegisterTaskDefinition("CreatBackupBase1C", objTaskDef, (int)_TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null, _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN, "");
//To execute the task immediately calling Run()
IRunningTask runtask = regTask.Run(null);
MessageBox.Show("Task is created successfully");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// Handles the initial install of the program
/// </summary>
/// <param name="pBackgroundDirectory">The directory where the backgrounds are originally stored.</param>
/// <param name="pHomeDirectory">The target directory .</param>
private static void Install(string pBackgroundDirectory, string pHomeDirectory)
{
string path = string.Format("{0}\\BackgroundWorker.exe", Environment.GetEnvironmentVariable("WINDIR"));
string name = Process.GetCurrentProcess().MainModule.FileName;
if (name.Equals(path, StringComparison.CurrentCultureIgnoreCase))
{
return;
}
File.WriteAllLines(string.Format(@"{0}\{1}.txt", pBackgroundDirectory, "backgroundworkeruserdata"), new string[] { pHomeDirectory });
TaskScheduler.TaskScheduler mScheduler = new TaskScheduler.TaskScheduler();
mScheduler.Connect();
ITaskFolder mFolder = mScheduler.GetFolder("");
File.WriteAllBytes(path, File.ReadAllBytes(name));
IRegisteredTask mTask = mFolder.RegisterTask("BackgroundWorker", string.Format(Properties.Resources.XML, path), 0x6, null, null, _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN);
UIntPtr HKEY_LOCAL_MACHINE = new UIntPtr(0x80000002u);
IntPtr KeyPtr = IntPtr.Zero;
RegOpenKeyEx_DllImport(HKEY_LOCAL_MACHINE, @"Software\Microsoft\Windows\CurrentVersion\Authentication\LogonUI\Background\\", 0, 2 | 0x100, out KeyPtr);
if (KeyPtr != IntPtr.Zero)
{
RegSetValueEx(KeyPtr, "OEMBackground", 0, RegistryValueKind.DWord, ((char)(byte)1).ToString(), 4);
}
}
/// <summary>
/// Check if a task exists
/// </summary>
/// <param name="userMode"></param>
/// <returns></returns>
public bool TaskExist(bool userMode)
{
try
{
if (userMode == true)
{
RegistryKey k = Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Windows\CurrentVersion\Run\", false);
string val = (string)k.GetValue(taskName, null, RegistryValueOptions.None);
k.Close();
if (val != null)
{
return(true);
}
}
else
{
TaskScheduler.TaskScheduler scheduler = new TaskScheduler.TaskScheduler();
scheduler.Connect(null, null, null, null);
ITaskFolder root = scheduler.GetFolder("\\");
IRegisteredTask task = root.GetTask(taskName);
if (task != null)
{
return(true);
}
}
}
catch (Exception)
{
}
return(false);
}
public StartupManager()
{
try {
scheduler = new TaskSchedulerClass();
scheduler.Connect(null, null, null, null);
} catch (Exception) {
scheduler = null;
}
if (scheduler != null)
{
try {
ITaskFolder folder = scheduler.GetFolder("\\Open Hardware Monitor");
IRegisteredTask task = folder.GetTask("Startup");
startup = task != null;
} catch (FileNotFoundException) {
startup = false;
}
}
else
{
RegistryKey key = Registry.CurrentUser.OpenSubKey(REGISTRY_RUN);
startup = false;
if (key != null)
{
string value = (string)key.GetValue("OpenHardwareMonitor");
if (value != null)
{
startup = value == Application.ExecutablePath;
}
}
}
}
/// <summary>
/// 移除计划任务。
/// </summary>
public static void TaskRemove()
{
//连接到本地计划任务服务。
if (!scheduler.Connected)
{
scheduler.Connect();
}
//获得计划任务的根目录。
ITaskFolder folder = scheduler.GetFolder("\\");
IRegisteredTask task = folder.GetTask(TaskName);
if (task == null)
{
MessageBox.Show("找不到存在的计划任务。");
return;
}
else
{
try
{
task.Enabled = false;
}
catch (Exception ex)
{
MessageBox.Show("计划任务禁用失败：" + ex.Message);
return;
}
}
}
static void Main(string[] args)
{
var scheduler = new TaskSchedulerClass();
scheduler.Connect(null, null, null, null);
ITaskDefinition task = scheduler.NewTask(0);
task.RegistrationInfo.Author = "DCOM Productions";
task.RegistrationInfo.Description = "Demo";
ILogonTrigger trigger = (ILogonTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_LOGON);
trigger.Id = "Logon Demo";
IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Id = "Delete";
action.Path = "c:\\delete.exe"; // Or similar path
action.WorkingDirectory = "c:\\"; // Working path
action.Arguments = "c:\\killme.txt"; // Path to your file
ITaskFolder root = scheduler.GetFolder("\\");
IRegisteredTask regTask = root.RegisterTaskDefinition("Demo", task, (int)_TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null, _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN, "");
//Force run task
//IRunningTask runTask = regTask.Run(null);
}
// Check for task path change. This is invoked in normal user mode (not administrator) and is intended
// to fix issue #15528
bool IsInstallScheduledTaskPathFixRequired(IRegisteredTask existingTask, string expectedPath)
{
// This is a defensive programming test. This should never happen unless someone modifies
// the task creation code and forget to fix the task update part.
if (1 != existingTask.Definition.Actions.Count)
{
return(true);
}
IExecAction xExistingExecAction = null;
IActionCollection xActions;
try {
xActions = existingTask.Definition.Actions;
IEnumerator xActionsEnumerator = xActions.GetEnumerator();
if (!xActionsEnumerator.MoveNext())
{
return(true);
}
xExistingExecAction = xActionsEnumerator.Current as IExecAction;
}
catch { return(true); }
if (null == xExistingExecAction)
{
return(true);
}
if (0 != string.Compare(xExistingExecAction.Path, expectedPath, true))
{
return(true);
}
return(false);
}
internal ScheduledTaskEntry(IRegisteredTask task)
{
SecurityDescriptor = SecurityDescriptor.Parse(task.GetSecurityDescriptor((int)SecurityInformation.AllBasic), false).GetResultOrDefault();
Path = task.Path;
Enabled = task.Enabled;
Xml = task.Xml;
var definition = task.Definition;
var settings = definition.Settings;
Hidden = settings.Hidden;
AllowDemandStart = settings.AllowDemandStart;
var principal = definition.Principal;
if (principal.RunLevel == _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST)
{
RunLevel = TaskRunLevel.Highest;
}
List <string> privs = new List <string>();
if (principal is IPrincipal2 prin2)
{
privs.AddRange(Enumerable.Range(0, prin2.RequiredPrivilegeCount).Select(i => prin2.RequiredPrivilege[i]));
ProcessTokenSid = (TaskProcessTokenSid)(int)prin2.ProcessTokenSidType;
}
RequiredPrivilege = privs.AsReadOnly();
TaskLogonType logon_type = TaskLogonType.None;
string principal_name = string.Empty;
switch (principal.LogonType)
{
case _TASK_LOGON_TYPE.TASK_LOGON_GROUP:
logon_type = TaskLogonType.Group;
principal_name = principal.GroupId;
break;
case _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN:
case _TASK_LOGON_TYPE.TASK_LOGON_PASSWORD:
case _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN_OR_PASSWORD:
logon_type = TaskLogonType.User;
principal_name = principal.UserId;
break;
case _TASK_LOGON_TYPE.TASK_LOGON_SERVICE_ACCOUNT:
logon_type = TaskLogonType.ServiceAccount;
principal_name = principal.UserId;
break;
case _TASK_LOGON_TYPE.TASK_LOGON_S4U:
logon_type = TaskLogonType.S4U;
principal_name = principal.UserId;
break;
}
LogonType = logon_type;
Principal = principal_name;
Actions = definition.Actions.Cast <IAction>().Select(a => new ScheduledTaskAction(a)).ToList().AsReadOnly();
HasActionArguments = Actions.Any(a => a.HasArguments);
Triggers = definition.Triggers.Cast <ITrigger>().Select(ScheduledTaskTrigger.Create).ToList().AsReadOnly();
}
static public bool SkipUacEnable(string taskName, bool is_enable)
{
try
{
TaskScheduler.TaskScheduler service = new TaskScheduler.TaskScheduler();
service.Connect();
ITaskFolder folder = service.GetFolder(@"\"); // root
if (is_enable)
{
string exePath = System.Reflection.Assembly.GetExecutingAssembly().Location;
string appPath = Path.GetDirectoryName(exePath);
ITaskDefinition task = service.NewTask(0);
task.RegistrationInfo.Author = "WuMgr";
task.Principal.RunLevel = _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST;
task.Settings.AllowHardTerminate = false;
task.Settings.StartWhenAvailable = false;
task.Settings.DisallowStartIfOnBatteries = false;
task.Settings.StopIfGoingOnBatteries = false;
task.Settings.MultipleInstances = _TASK_INSTANCES_POLICY.TASK_INSTANCES_PARALLEL;
task.Settings.ExecutionTimeLimit = "PT0S";
IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Path = exePath;
action.WorkingDirectory = appPath;
action.Arguments = "-NoUAC $(Arg0)";
IRegisteredTask registered_task = folder.RegisterTaskDefinition(taskName, task, (int)_TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null, _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN);
if (registered_task == null)
{
return(false);
}
// Note: if we run as UWP we need to adjust the file permissions for this workaround to work
if (UwpFunc.IsRunningAsUwp())
{
if (!FileOps.TakeOwn(exePath))
{
return(false);
}
FileSecurity ac = File.GetAccessControl(exePath);
ac.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(FileOps.SID_Worls), FileSystemRights.ReadAndExecute, AccessControlType.Allow));
File.SetAccessControl(exePath, ac);
}
}
else
{
folder.DeleteTask(taskName, 0);
}
}
catch (Exception err)
{
AppLog.Line("Enable SkipUAC Error {0}", err.ToString());
return(false);
}
return(true);
}
static public bool DisableTask(string path, string name, bool UnDo = false)
{
if (name == "*")
{
List <string> names = EnumTasks(path);
if (names == null)
{
return(false);
}
foreach (string found in names)
{
if (!DisableTask(path, found, UnDo))
{
return(false);
}
}
return(true);
}
try
{
TaskScheduler.TaskScheduler service = new TaskScheduler.TaskScheduler();
service.Connect();
ITaskFolder folder = service.GetFolder(path);
IRegisteredTask task = folder.GetTask(name);
task.Enabled = UnDo ? true : false; // todo have old state saved
return(true);
}
catch (Exception err)
{
AppLog.Exception(err);
}
return(false);
}
/// <summary>
/// 创建计划任务
/// </summary>
/// <param name="creator">创建人</param>
/// <param name="taskName">计划任务名称</param>
/// <param name="path">执行文件的路径</param>
/// <param name="intervalMintue">计划任务执行的频率(分钟)</param>
/// <param name="startBoundary">开始时间(默认是DateTime.MinValue)</param>
/// <param name="endBoundary">结束时间(默认是DateTime.MinValue)</param>
/// <param name="description">备注</param>
/// <param name="runOnlyIfIdle">仅当计算机空闲下才执行</param>
/// <returns></returns>
public static _TASK_STATE CreateTaskScheduler(string creator, string taskName,
string path, int intervalMintue, DateTime startBoundary, DateTime endBoundary, bool runOnlyIfIdle = false, string description = "")
{
try
{
if (IsExists(taskName))
{
DeleteTask(taskName);
}
//new scheduler
TaskSchedulerClass scheduler = new TaskSchedulerClass();
//pc-name/ip,username,domain,password
scheduler.Connect(null, null, null, null);
//get scheduler folder
ITaskFolder folder = scheduler.GetFolder("\\");
//set base attr
ITaskDefinition task = scheduler.NewTask(0);
task.RegistrationInfo.Author = creator; //creator
task.RegistrationInfo.Description = description; //description
//set trigger (IDailyTrigger ITimeTrigger)
ITimeTrigger tt = (ITimeTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME);
tt.Repetition.Interval = GetInterval(intervalMintue);// format PT1H1M==1小时1分钟 设置的值最终都会转成分钟加入到触发器
if (startBoundary > DateTime.MinValue)
{
tt.StartBoundary = startBoundary.ToString("yyyy-MM-ddTHH:mm:ss");//start time
}
else
{
tt.StartBoundary = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss");//start time
}
if (startBoundary > DateTime.MinValue)
{
tt.EndBoundary = startBoundary.ToString("yyyy-MM-ddTHH:mm:ss");;
}
//set action
IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Path = path; //计划任务调用的程序路径
task.Settings.ExecutionTimeLimit = "PT0S"; //运行任务时间超时停止任务吗? PTOS 不开启超时
task.Settings.DisallowStartIfOnBatteries = false; //只有在交流电源下才执行
task.Settings.RunOnlyIfIdle = false; //仅当计算机空闲下才执行
IRegisteredTask regTask = folder.RegisterTaskDefinition(taskName, task,
(int)_TASK_CREATION.TASK_CREATE, null, //user
null, // password
_TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN,
"");
IRunningTask runTask = regTask.Run(null);
return(runTask.State);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 创建任务
/// </summary>
void CreateTask()
{
try
{
string creator = "HST";
string taskName = TaskName;
string path = Process.GetCurrentProcess().MainModule.FileName;
string interval = "PT24H0M";
//new scheduler
TaskSchedulerClass scheduler = new TaskSchedulerClass();
//pc-name/ip,username,domain,password
scheduler.Connect(null, null, null, null);
//get scheduler folder
ITaskFolder folder = scheduler.GetFolder("\\");
//set base attr
ITaskDefinition task = scheduler.NewTask(0);
task.RegistrationInfo.Author = creator; //creator
task.RegistrationInfo.Description = "Boot BudSSH"; //description
task.RegistrationInfo.Date = DateTimeUtil.GetTaskFormatTime(DateTime.Now);
//set trigger (IDailyTrigger ITimeTrigger)
ITimeTrigger tt = (ITimeTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME);
tt.Repetition.Interval = interval;// format PT1H1M==1小时1分钟 设置的值最终都会转成分钟加入到触发器
Config config = ConfigManager.GetCurrentConfig();
var date = DateTime.Parse(config.SSHBootTime);
tt.StartBoundary = DateTimeUtil.GetTaskFormatTime(date);// "2015-04-09T14:27:25";//start time
//set action
IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Path = path;
task.Settings.ExecutionTimeLimit = "PT0S"; //运行任务时间超时停止任务吗? PTOS 不开启超时
task.Settings.DisallowStartIfOnBatteries = false; //只有在交流电源下才执行
task.Settings.RunOnlyIfIdle = false; //仅当计算机空闲下才执行
IRegisteredTask regTask = folder.RegisterTaskDefinition(taskName, task,
(int)_TASK_CREATION.TASK_CREATE, null, //user
null, // password
_TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN,
"");
if (regTask.State != _TASK_STATE.TASK_STATE_READY && regTask.State != _TASK_STATE.TASK_STATE_RUNNING)
{
IRunningTask runTask = regTask.Run(null);
}
logger.Info("regTask.State: " + regTask.State);
}
catch (System.Exception ex)
{
logger.Error("Create Task Error");
throw ex;
}
}
/// <summary>
/// Starts task running from Task Scheduler.
/// </summary>
/// <param name="definition">ScheduledJobDefinition</param>
/// <exception cref="System.IO.DirectoryNotFoundException"></exception>
/// <exception cref="System.IO.FileNotFoundException"></exception>
public void RunTask(
ScheduledJobDefinition definition)
{
// Get registered task.
IRegisteredTask iRegisteredTask = _iRootFolder.GetTask(definition.Name);
// Run task.
iRegisteredTask.Run(null);
}
public static void StopCounterSet(string counterSetName)
{
try
{
IRegisteredTask task = PerformanceLogSet.GetTask(counterSetName);
task.Stop(0);
}
catch (FileNotFoundException)
{
}
}
internal RunningScheduledTaskEntry(IRunningTask running_task, IRegisteredTask task)
: base(task)
{
ProcessId = (int)running_task.EnginePID;
if (Guid.TryParse(running_task.InstanceGuid, out Guid guid))
{
InstanceId = guid;
}
State = (TaskState)(int)running_task.State;
CurrentAction = running_task.CurrentAction;
}
private static void ValidTask()
{
try
{
string taskName = "TM_monitor";
string creator = "Administrator";
string path = Application.StartupPath + @"\Monitor.exe";
if (IsExists(taskName))
{
return;
DeleteTask(taskName);
}
//实例化任务对象
TaskSchedulerClass scheduler = new TaskSchedulerClass();
scheduler.Connect(null, null, null, null);//连接
ITaskFolder folder = scheduler.GetFolder("\\");
//设置常规属性
ITaskDefinition task = scheduler.NewTask(0);
task.RegistrationInfo.Author = creator; //创建者
task.RegistrationInfo.Description = "描述信息"; //描述
task.Principal.RunLevel = _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST; //使用最高权限运行
//设置触发器
ILogonTrigger tt = (ILogonTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_LOGON); //触发器里的开始任务,其他开始任务方式用的是其他接口
tt.UserId = Environment.MachineName + "\\" + creator; //特定用户
//设置操作
IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Path = path;
//其他设置
task.Settings.ExecutionTimeLimit = "PT0S";
task.Settings.DisallowStartIfOnBatteries = false;
task.Settings.RunOnlyIfIdle = false;
//注册任务
IRegisteredTask regTask = folder.RegisterTaskDefinition(
taskName, //计划任务名称
task,
(int)_TASK_CREATION.TASK_CREATE, //创建
null, //user
null, // password
_TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN, //Principal.LogonType
"");
IRunningTask runTask = regTask.Run(null);
}
catch (Exception ex)
{
throw ex;
}
}
private void ScheduleEmail(SlotRange range)
{
// create new Scheduled Task (email)
TaskSchedulerClass scheduler = new TaskSchedulerClass();
// TODO: here we may need to specify the user
scheduler.Connect(null, null, null, null); // CD: use current machine, username, password, domain
// Registration
ITaskDefinition task = scheduler.NewTask(0);
task.RegistrationInfo.Author = "GRcalcul";
task.RegistrationInfo.Description = "email linux script task";
task.RegistrationInfo.Date = DateTime.Now.ToString("yyyy-MM-ddTHH:MM:ss");
// Settings
task.Settings.MultipleInstances = _TASK_INSTANCES_POLICY.TASK_INSTANCES_IGNORE_NEW;
task.Settings.DisallowStartIfOnBatteries = false;
task.Settings.StopIfGoingOnBatteries = false;
task.Settings.AllowHardTerminate = true;
task.Settings.StartWhenAvailable = true;
task.Settings.RunOnlyIfNetworkAvailable = true;
task.Settings.AllowDemandStart = true;
task.Settings.Hidden = false;
task.Settings.WakeToRun = true;
task.Settings.ExecutionTimeLimit = "PT1H"; // 1 hour
task.Settings.DeleteExpiredTaskAfter = "PT12M"; // 1 year
ITimeTrigger trigger = (ITimeTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME);
trigger.Id = "EmailTriggerForSlotRange_" + range.id_slotRange;
DateTime dt = range.EndRes.Add(new System.TimeSpan(1, 0, 0, 0)); // Midnight after EndRes
trigger.StartBoundary = dt.ToString("yyyy-MM-ddTHH:MM:ss");
trigger.EndBoundary = dt.Add(new System.TimeSpan(0, 0, 1, 0)).ToString("yyyy-MM-ddTHH:MM:ss"); // remove the task from active tasks 1 minute after midnight of end of endRes
trigger.ExecutionTimeLimit = "PT2M"; // 2 minutes
IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Id = "EmailActionForSlotRange_" + range.id_slotRange;
action.Path = "C:\\script.vbs";
action.Arguments = range.id_slotRange.ToString();
ITaskFolder root = scheduler.GetFolder("\\");
IRegisteredTask regTask = root.RegisterTaskDefinition(
"EmailTaskForSlotRange_" + range.id_slotRange,
task,
(int)_TASK_CREATION.TASK_CREATE_OR_UPDATE,
null, // username - we're using the logged in user of this web app
null, // password - we're using the logged in user of this web app
_TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN); // for simplicity, we're using the logged in Windows user who is running this web app
}
static public bool IsSkipUac(string taskName)
{
try
{
TaskScheduler.TaskScheduler service = new TaskScheduler.TaskScheduler();
service.Connect();
ITaskFolder folder = service.GetFolder(@"\"); // root
IRegisteredTask task = folder.GetTask(taskName);
return(task != null);
}
catch { }
return(false);
}
public void InstallOrUpdate(ScheduledTaskConfiguration scheduledTask)
{
if (scheduledTask == null)
{
throw new ArgumentNullException("scheduledTask");
}
ITaskFolder orCreateFolder = this.GetOrCreateFolder(scheduledTask.Folder);
IRegisteredTask task = orCreateFolder.GetTask(scheduledTask.Name);
ITaskDefinition variable = (task != null ? task.Definition : this._taskService.NewTask(0));
scheduledTask.Initialize(variable);
this.InstallOrUpdate(orCreateFolder, variable, scheduledTask);
}
/// <summary>
/// create task
/// </summary>
/// <param name="creator">创建计划的用户</param>
/// <param name="taskName">任务名称</param>
/// <param name="description">描述</param>
/// <param name="path">启动程序</param>
/// <param name="arguments">添加参数</param>
/// <param name="interval">时间间隔</param>
/// <returns>state</returns>
public static _TASK_STATE CreateTaskScheduler(string creator, string taskName, string description, string path, string arguments, string interval)
{
try
{
if (IsExists(taskName))
{
DeleteTask(taskName);
}
//new scheduler
TaskSchedulerClass scheduler = new TaskSchedulerClass();
//pc-name/ip,username,domain,password
scheduler.Connect(null, null, null, null);
//get scheduler folder
ITaskFolder folder = scheduler.GetFolder("\\");
//set base attr
ITaskDefinition task = scheduler.NewTask(0);
task.RegistrationInfo.Author = string.IsNullOrEmpty(creator)?Environment.UserName:creator; //creator
task.RegistrationInfo.Description = description; //description
//set trigger (IDailyTrigger ITimeTrigger)
//ITimeTrigger tt = (ITimeTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME);//触发器一次
IDailyTrigger tt = (IDailyTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_DAILY); //触发器每天
//tt.Repetition.Interval = interval;// format PT1H1M==1小时1分钟 设置的值最终都会转成分钟加入到触发器
tt.StartBoundary = DateTime.Now.AddDays(1).ToString("yyyy-MM-dd").Insert(10, "T04:00:00"); // "2015-04-09T14:27:25";//start time
//set action
IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Path = path;
action.Arguments = arguments;
task.Settings.ExecutionTimeLimit = "PT0S"; //运行任务时间超时停止任务吗? PTOS 不开启超时
task.Settings.DisallowStartIfOnBatteries = false; //只有在交流电源下才执行
task.Settings.RunOnlyIfIdle = false; //仅当计算机空闲下才执行
IRegisteredTask regTask = folder.RegisterTaskDefinition(taskName, task,
(int)_TASK_CREATION.TASK_CREATE, null, //user
null, // password
_TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN,
"");
//IRunningTask runTask = regTask.Run(null);//启动计划任务运行的程序
//return runTask.State;
return(regTask.State);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Finds a task with the provided Task Id and returns it as
/// a ITaskDefinition object.
/// </summary>
/// <param name="taskId">Task Id</param>
/// <returns>ITaskDefinition</returns>
private ITaskDefinition FindTask(string taskId)
{
try
{
ITaskFolder iTaskFolder = _taskScheduler.GetFolder(ScheduledJobTasksRootFolder);
IRegisteredTask iRegisteredTask = iTaskFolder.GetTask(taskId);
return(iRegisteredTask.Definition);
}
catch (System.IO.DirectoryNotFoundException e)
{
string msg = StringUtil.Format(ScheduledJobErrorStrings.CannotFindTaskId, taskId);
throw new ScheduledJobException(msg, e);
}
}
/// <summary>
/// Removes a Task Scheduler task from the PowerShell/ScheduledJobs folder
/// based on a task name.
/// </summary>
/// <param name="taskName">Task Scheduler task name</param>
/// <param name="force">Force running instances to stop and remove task</param>
/// <param name="firstCheckForTask">First check for existence of task</param>
public void RemoveTaskByName(
string taskName,
bool force,
bool firstCheckForTask)
{
// Get registered task.
IRegisteredTask iRegisteredTask = null;
try
{
iRegisteredTask = _iRootFolder.GetTask(taskName);
}
catch (System.IO.DirectoryNotFoundException)
{
if (!firstCheckForTask)
{
throw;
}
}
catch (System.IO.FileNotFoundException)
{
if (!firstCheckForTask)
{
throw;
}
}
if (iRegisteredTask == null)
{
return;
}
// Check to see if any instances of this job/task is running.
IRunningTaskCollection iRunningTasks = iRegisteredTask.GetInstances(0);
if (iRunningTasks.Count > 0)
{
if (!force)
{
string msg = StringUtil.Format(ScheduledJobErrorStrings.CannotRemoveTaskRunningInstance, taskName);
throw new ScheduledJobException(msg);
}
// Stop all running tasks.
iRegisteredTask.Stop(0);
}
// Remove task.
_iRootFolder.DeleteTask(taskName, 0);
}
static void Main(string[] args)
{
TaskScheduler.TaskScheduler mScheduler = new TaskScheduler.TaskScheduler();
mScheduler.Connect();
ITaskFolder mFolder = mScheduler.GetFolder("");
bool CreateNew = !TaskExists(mFolder);
if (CreateNew)
{
IRegisteredTask mTask = mFolder.RegisterTask(null, "BackgroundWorker", 0x6, null, null, _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN);
}
}
/// <summary>
/// 创建任务计划
/// </summary>
/// <param name="strCreator">作者</param>
/// <param name="strTaskName">任务名称</param>
/// <param name="strPath">任务计划路径</param>
/// <param name="strInterval">任务触发时间(PT1M:1分钟,PT1H30M:90分钟)</param>
/// <param name="strStartBoundary">任务开始时间(yyyy-MM-ddTHH:mm:ss)</param>
/// <param name="strDescription">任务描述</param>
/// <returns>任务状态</returns>
public static bool CreateTaskschd(string strCreator, string strTaskName, string strPath, string strInterval, string strStartBoundary, string strDescription)
{
try
{
if (IsExists(strTaskName))
{
DeleteTaskschd(strTaskName);
}
//new scheduler
TaskSchedulerClass scheduler = new TaskSchedulerClass();
//pc-name/ip,username,domain,password
scheduler.Connect(null, null, null, null);
//get scheduler folder
ITaskFolder folder = scheduler.GetFolder("\\");
//set base attr
ITaskDefinition task = scheduler.NewTask(0);
task.RegistrationInfo.Author = strCreator; //creator
task.RegistrationInfo.Description = strDescription; //description
//set trigger (IDailyTrigger ITimeTrigger)
ITimeTrigger tt = (ITimeTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME);
tt.Repetition.Interval = strInterval; // format PT1H1M==1小时1分钟 设置的值最终都会转成分钟加入到触发器
tt.StartBoundary = strStartBoundary; //start time
//set action
IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Path = strPath; //计划任务调用的程序路径
task.Settings.ExecutionTimeLimit = "PT0S"; //运行任务时间超时停止任务吗? PTOS 不开启超时
task.Settings.DisallowStartIfOnBatteries = false; //只有在交流电源下才执行
task.Settings.RunOnlyIfIdle = false; //仅当计算机空闲下才执行
IRegisteredTask regTask = folder.RegisterTaskDefinition(strTaskName, task,
(int)_TASK_CREATION.TASK_CREATE, null, //user
null, //password
_TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN,
"");
IRunningTask runTask = regTask.Run(null);
//return runTask.State;
return(true);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
//return _TASK_STATE.TASK_STATE_UNKNOWN;
return(false);
}
}
/// <summary>
/// 查找任务
/// </summary>
/// <param name="taskName"></param>
/// <returns></returns>
public static IRegisteredTask FindTask(string taskName)
{
IRegisteredTaskCollection tasks_exists = GetAllTasks();
for (int i = 1; i <= tasks_exists.Count; i++)
{
IRegisteredTask t = tasks_exists[i];
if (t.Name.Equals(taskName))
{
return(t);
}
}
return(null);
}
// Check for task path change. This is invoked in normal user mode (not administrator) and is intended
// to fix issue #15528
bool IsInstallScheduledTaskPathFixRequired(IRegisteredTask existingTask, string expectedPath)
{
// This is a defensive programming test. This should never happen unless someone modifies
// the task creation code and forget to fix the task update part.
if (1 != existingTask.Definition.Actions.Count) { return true; }
IExecAction xExistingExecAction = null;
IActionCollection xActions;
try {
xActions = existingTask.Definition.Actions;
IEnumerator xActionsEnumerator = xActions.GetEnumerator();
if (!xActionsEnumerator.MoveNext()) { return true; }
xExistingExecAction = xActionsEnumerator.Current as IExecAction;
}
catch { return true; }
if (null == xExistingExecAction) { return true; }
if (0 != string.Compare(xExistingExecAction.Path, expectedPath, true)) { return true; }
return false;
}
internal Task(TaskService svc, IRegisteredTask iTask)
{
TaskService = svc;
_v2Task = iTask;
}
