trigger.cs

一个可以生成windows定时任务的程序

using System;
using System.Collections;
using System.IO;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;
using TaskSchedulerInterop;

namespace TaskScheduler
{
	#region Enums
	/// <summary>
	/// Valid types of triggers
	/// </summary>
	public enum TriggerType
	{
		/// <summary>
		/// Trigger is set to run the task a single time. 
		/// </summary>
		RunOnce = 0,
		/// <summary>
		/// Trigger is set to run the task on a daily interval. 
		/// </summary>
		RunDaily = 1,
		/// <summary>
		/// Trigger is set to run the work item on specific days of a specific week of a specific month. 
		/// </summary>
		RunWeekly = 2,
		/// <summary>
		/// Trigger is set to run the task on a specific day(s) of the month.
		/// </summary>
		RunMonthly = 3,
		/// <summary>
		/// Trigger is set to run the task on specific days, weeks, and months.
		/// </summary>
		RunMonthlyDOW = 4,
		/// <summary>
		/// Trigger is set to run the task if the system remains idle for the amount of time specified by the idle wait time of the task.
		/// </summary>
		OnIdle = 5,
		/// <summary>
		/// Trigger is set to run the task at system startup.
		/// </summary>
		OnSystemStart = 6,
		/// <summary>
		/// Trigger is set to run the task when a user logs on. 
		/// </summary>
		OnLogon = 7
	}

	/// <summary>
	/// Values for days of the week (Monday, Tuesday, etc.)
	/// </summary>
	[Flags]
	public enum DaysOfTheWeek : short
	{
		/// <summary>
		/// Sunday
		/// </summary>
		Sunday = 0x1,
		/// <summary>
		/// Monday
		/// </summary>
		Monday = 0x2,
		/// <summary>
		/// Tuesday
		/// </summary>
		Tuesday = 0x4,
		/// <summary>
		/// Wednesday
		/// </summary>
		Wednesday = 0x8,
		/// <summary>
		/// Thursday
		/// </summary>
		Thursday = 0x10,
		/// <summary>
		/// Friday
		/// </summary>
		Friday = 0x20,
		/// <summary>
		/// Saturday
		/// </summary>
		Saturday = 0x40
	}

	/// <summary>
	/// Values for week of month (first, second, ..., last)
	/// </summary>
	public enum WhichWeek : short
	{
		/// <summary>
		/// First week of the month
		/// </summary>
		FirstWeek = 1,
		/// <summary>
		/// Second week of the month
		/// </summary>
		SecondWeek = 2,
		/// <summary>
		/// Third week of the month
		/// </summary>
		ThirdWeek = 3,
		/// <summary>
		/// Forth week of the month
		/// </summary>
		FourthWeek = 4,
		/// <summary>
		/// Last week of the month
		/// </summary>
		LastWeek = 5
	}

	/// <summary>
	/// Values for months of the year (January, February, etc.)
	/// </summary>
	[Flags]
	public enum MonthsOfTheYear : short
	{
		/// <summary>
		/// January
		/// </summary>
		January = 0x1,
		/// <summary>
		/// February
		/// </summary>
		February = 0x2,
		/// <summary>
		/// March
		/// </summary>
		March = 0x4,
		/// <summary>
		/// April
		/// </summary>
		April = 0x8,
		/// <summary>
		///May 
		/// </summary>
		May = 0x10,
		/// <summary>
		/// June
		/// </summary>
		June = 0x20,
		/// <summary>
		/// July
		/// </summary>
		July = 0x40,
		/// <summary>
		/// August
		/// </summary>
		August = 0x80,
		/// <summary>
		/// September
		/// </summary>
		September = 0x100,
		/// <summary>
		/// October
		/// </summary>
		October = 0x200,
		/// <summary>
		/// November
		/// </summary>
		November = 0x400,
		/// <summary>
		/// December
		/// </summary>
		December = 0x800
	}
	#endregion

	/// <summary>
	/// Trigger encapsulates the triggers associated with tasks.
	/// </summary>
	public abstract class Trigger : IDisposable
	{
		#region Enums
		/// <summary>
		/// Flags for triggers
		/// </summary>
		[Flags]
		private enum TaskTriggerFlags
		{
			HasEndDate = 0x1,
			KillAtDurationEnd = 0x2,
			Disabled = 0x4
		}
		#endregion

		#region Fields
		private ITaskTrigger iTaskTrigger;
		internal TaskTrigger taskTrigger;
		#endregion

		#region Constructors and Initializers
		/// <summary>
		/// Internal bsae constructor
		/// </summary>
		internal Trigger()
		{
			taskTrigger.TriggerSize = (ushort)Marshal.SizeOf(taskTrigger);
			taskTrigger.BeginYear = (ushort)DateTime.Today.Year;
			taskTrigger.BeginMonth = (ushort)DateTime.Today.Month;
			taskTrigger.BeginDay = (ushort)DateTime.Today.Day;
		}

		/// <summary>
		/// Internal constructor which initializes itself with values
		/// from current ITaskTrigger interface
		/// </summary>
		/// <param name="iTrigger">Instance of ITaskTrigger from task</param>
		internal Trigger(ITaskTrigger iTrigger)
		{
			if (iTrigger == null)
				throw new ArgumentNullException("iTrigger", "ITaskTrigger instance cannot be null");
			iTrigger.GetTrigger(ref taskTrigger);
			iTaskTrigger = iTrigger;
		}

		/// <summary>
		/// Internal copy constructor
		/// </summary>
		/// <param name="t">Trigger to copy</param>
		internal Trigger(Trigger t)
		{
			taskTrigger = t.taskTrigger;
			iTaskTrigger = t.iTaskTrigger;
		}
		#endregion

		#region Properties
		/// <summary>
		/// Internal: Gets value for taskTrigger
		/// </summary>
		internal TaskTrigger InternalTaskTrigger
		{
			get
			{
				return taskTrigger;
			}
		}

		/// <summary>
		/// Gets type of trigger
		/// </summary>
		public TriggerType Type
		{
			get
			{
				return (TriggerType)taskTrigger.Type;
			}
		}

		/// <summary>
		/// Gets/sets the beginning year, month, and day for the trigger
		/// </summary>
		public DateTime BeginDate
		{
			get
			{
				return new DateTime(taskTrigger.BeginYear, taskTrigger.BeginMonth, taskTrigger.BeginDay);
			}
			set
			{
				taskTrigger.BeginYear = (ushort)value.Year;
				taskTrigger.BeginMonth = (ushort)value.Month;
				taskTrigger.BeginDay = (ushort)value.Day;
			}
		}
			
		/// <summary>
		/// Gets/sets the ending year, month, and day for the trigger
		/// </summary>
		public DateTime EndDate
		{
			get
			{
				if (taskTrigger.EndYear == 0)
					return DateTime.MinValue;
				return new DateTime(taskTrigger.EndYear, taskTrigger.EndMonth, taskTrigger.EndDay);
			}
			set
			{
				taskTrigger.Flags |= (uint)TaskTriggerFlags.HasEndDate;
				taskTrigger.EndYear = (ushort)value.Year;
				taskTrigger.EndMonth = (ushort)value.Month;
				taskTrigger.EndDay = (ushort)value.Day;
			}
		}

		/// <summary>
		/// Gets/sets the number of minutes after the task starts that the trigger will remain active.
		/// </summary>
		public int DurationMinutes
		{
			get
			{
				return (int)taskTrigger.MinutesDuration;
			}
			set
			{
				if (value < taskTrigger.MinutesInterval)
					throw new ArgumentOutOfRangeException("DurationMinutes", value, "DurationMinutes must be greater than or equal the IntervalMinutes value");
				taskTrigger.MinutesDuration = (ushort)value;
			}
		}

		/// <summary>
		/// Gets/sets the number of minutes between consecutive task executions. This number is counted from the start of the previous task.
		/// </summary>
		public int IntervalMinutes
		{
			get
			{
				return (int)taskTrigger.MinutesInterval;
			}
			set
			{
				if (value > taskTrigger.MinutesDuration)
					throw new ArgumentOutOfRangeException("IntervalMinutes", value, "IntervalMinutes must be less than or equal the DurationMinutes value");
				taskTrigger.MinutesInterval = (uint)value;
			}
		}

		/// <summary>
		/// Gets/sets whether task will be killed (terminated) at the end of the task duration. See <see cref="Trigger.DurationMinutes"/>.
		/// </summary>
		public bool KillAtDurationEnd
		{
			get
			{
				return ((taskTrigger.Flags | (uint)TaskTriggerFlags.KillAtDurationEnd) == (uint)TaskTriggerFlags.KillAtDurationEnd);
			}
			set
			{
				if (value)
					taskTrigger.Flags |= (uint)TaskTriggerFlags.KillAtDurationEnd;
				else
					taskTrigger.Flags &= ~(uint)TaskTriggerFlags.KillAtDurationEnd;
			}
		}

		/// <summary>
		/// Gets/sets whether trigger is disabled
		/// </summary>
		public bool Disabled
		{
			get
			{
				return ((taskTrigger.Flags | (uint)TaskTriggerFlags.Disabled) == (uint)TaskTriggerFlags.Disabled);
			}
			set
			{
				if (value)
					taskTrigger.Flags |= (uint)TaskTriggerFlags.Disabled;
				else
					taskTrigger.Flags &= ~(uint)TaskTriggerFlags.Disabled;
			}
		}
		#endregion

		#region Methods
		/// <summary>
		/// Gets a new trigger based on type
		/// </summary>
		/// <param name="iTaskTrigger">Instance of ITaskTrigger</param>
		/// <returns>Type specific Trigger</returns>
		internal static Trigger GetTypedTrigger(ITaskTrigger iTaskTrigger)
		{
			if (iTaskTrigger == null)
				throw new ArgumentNullException("iTaskTrigger", "Instance of ITaskTrigger cannot be null");
			TaskTrigger sTaskTrigger = new TaskTrigger();
			sTaskTrigger.TriggerSize = (ushort)Marshal.SizeOf(sTaskTrigger);
			iTaskTrigger.GetTrigger(ref sTaskTrigger);
			switch ((TriggerType)sTaskTrigger.Type)
			{
				case TriggerType.RunOnce:
					return new RunOnceTrigger(iTaskTrigger);
				case TriggerType.RunDaily:
					return new DailyTrigger(iTaskTrigger);
				case TriggerType.RunWeekly:
					return new WeeklyTrigger(iTaskTrigger);
				case TriggerType.RunMonthlyDOW:
					return new MonthlyDOWTrigger(iTaskTrigger);
				case TriggerType.RunMonthly:
					return new MonthlyTrigger(iTaskTrigger);
				case TriggerType.OnIdle:
					return new OnIdleTrigger(iTaskTrigger);
				case TriggerType.OnSystemStart:
					return new OnSystemStartTrigger(iTaskTrigger);
				case TriggerType.OnLogon:
					return new OnLogonTrigger(iTaskTrigger);
			}
			throw new ArgumentException("Unable to recognize type of trigger referenced in iTaskTrigger", "iTaskTrigger");
		}

		/// <summary>
		/// Gets the string represenation of the trigger
		/// </summary>
		/// <returns>String representation of the trigger</returns>
		public override string ToString()
		{
			if (iTaskTrigger != null) 
			{
				string s;
				iTaskTrigger.GetTriggerString(out s);
				return s;
			}
			return null;
		}

		/// <summary>
		/// Determines if two triggers are internally equivalent
		/// </summary>
		/// <param name="obj">Value of trigger to compare</param>
		/// <returns>true if triggers are internally equal</returns>
		public override bool Equals(object obj)
		{
			Trigger trigger = (Trigger)obj;
			return taskTrigger.Equals(trigger.InternalTaskTrigger);
		}

		/// <summary>
		/// Gets a hash code for the current trigger
		/// </summary>
		/// <returns>Hash code</returns>
		public override int GetHashCode()
		{
			return taskTrigger.GetHashCode();
		}
		#endregion

		#region Implementation of IDisposable
		/// <summary>