Zdrojové kódy pro vývojáře.
Přeskočit odkazy pro navigaci Top 10 přispěvatelů
UživatelČlánky
codeshare45
sochor1
stoupa1
tomas.oplt15
Článek: Plánovač úloh - windows služba
Špatný Super
Autor:
Vytvořeno:
Popularita:

Plánovač úloh je Windows služba určená pro plánování spuštění různých úloh v určeném čase

Tato služba má dvě dvě hlavní funkcionality: 
Spuštění úlohy v přesně definovaném čase například 16:30 
Spuštění úlohy v určitém intervalu napříkald kažou hodinu. 

Jednotlivé úlohy jsou definované v XML souboru.
Aplikace při spuštění načte XML soubor a načte specifikované úlohy.

Definice tabulky pro uložení jednotlivých úloh:

scheduler_id: ID řádku ( unikátní databázové pole )
task_Name: Popis úlohy
task_uid: Unikátní identifikátor úlohy
active_task: Je úloha aktivní - má jí plánovač spouštět ?
task_scheduleType: 1 - Intervalový typ úlohy 2)  Přesný čas spuštění úlohy
task_interval_Sec: Interval ve vteřinách
task_Time: Čas spuštění úlohy
LastExecTime: Čas posledního spuštění úlohy
Priority: Prioria
day1_limit: Číslo jedna značí restrikci na čas spuštění úlohy pro den: pondělí
day1_from: Časový interval "od" ve kterém se úloha bude spouštět 
day1_to: Časový interval "do" ve kterém se úloha bude spouštět 
day2_limit: Číslo jedna značí restrikci na čas spuštění úlohy pro den: Úterý
day2_from: Časový interval "od" ve kterém se úloha bude spouštět day2_to: Allowed time range
day2_to: Časový interval "do" ve kterém se úloha bude spouštět 

Služba načítá data z XML souboru každých 5 minut. Pokud provedete v databázi změnu, nejpozději do 5ti minut se změna projeví
Hlavní třída která má na starosti spouštění jednotlivých úloh obsahuje dvě hlavní metody

LoadTasks - Načte úlohy z XML souboru
CheckTasks - Kontroluje zda není třeba spustit úlohu

Každá úloha musí dědit z bázové třídy Task která obsahuje
///


/// Bázová třída pro úlohy
///

public class Task
{
 private DateTime     m_dtTaskTime;
 private DateTime     m_dtLastProcessTime;
 private int    ?  m_intSchedulerTaskID;
 private ScheduleTaskEnum   m_TaskType;
 private int          ?  m_intTaskInterval;
private string             m_strTask_UID;
 private bool   []    m_bDayLimit;
 private DateTime     []    m_dtDateLimitFrom;
 private DateTime     []    m_dtDateLimitTo;
private bool               m_bActive;

 

 public Task()
{
  m_bDayLimit       = new bool[7];
  m_dtDateLimitFrom = new DateTime[7];
  m_dtDateLimitTo   = new DateTime[7];
  m_bActive         = true;

  m_dtTaskTime   = DateTime.Now;
  m_dtLastProcessTime     = DateTime.Now.AddDays(-1);
  m_TaskType    = ScheduleTaskEnum.SCHEDULER_TASK_UNKNOWN;
  m_intTaskInterval       = null;

  DateTime dt1999 = new DateTime(1999,1,1);
  for ( int i = 0; i < 7; i++)
  {
   DateLimitFrom[i] = dt1999;
   DateLimitTo[i]     = dt1999;
   m_bDayLimit[i]       = false;
  }

 }

    ///


    /// Default state
    ///
    public void ClearState()
    {
        m_dtLastProcessTime = new DateTime(1999, 1, 1, 0, 0, 0);
    }

    ///


    /// Active task ?
    ///
    public bool Active
    {
        get { return m_bActive; }
        set { m_bActive = value; }
    }


 ///


 /// Run task
 ///
 public virtual void DoIt()
 {
  if ( m_TaskType == ScheduleTaskEnum.SCHEDULER_TASK_UNKNOWN )
  Console.WriteLine("UNKNOWN");

  throw new ApplicationException("Necessary to override this method !");
 }


 ///


 /// Task time
 ///
 public DateTime TaskTime
 {
  get
  {
   return m_dtTaskTime;
  }
  set
  {
   m_dtTaskTime = value;
  }
 }




 ///
 /// Last exec time
 ///
 public DateTime LastProcessTime
 {
  get
  {
   return m_dtLastProcessTime;
  }
  set
  {
   m_dtLastProcessTime = value;
  }
 }


 ///


 /// Task ID from database
 ///
 public int ? SchedulerTaskID
 {
  get
  {
   return m_intSchedulerTaskID;
  }
  set
  {
   m_intSchedulerTaskID = value;
  }
 }
 ///
 /// Task Type
 ///
 public ScheduleTaskEnum TaskType
 {
  get
  {
   return m_TaskType;
  }
  set
  {
   m_TaskType = value;
  }
 }
 ///
 /// Task interval - sec
 ///
 public int ? TaskInterval
 {
  get
  {
   return m_intTaskInterval;
  }
  set
  {
   m_intTaskInterval = value;
  }
 }
 ///
 /// Unique task ID
 ///
public string Task_UID
 {
  get
  {
            return m_strTask_UID;
  }
  set
  {
            m_strTask_UID = value;
  }
 }
 ///
 /// Day limit restriction
 ///
 public bool [] DayLimit
 {
  get
  {
   return m_bDayLimit;
  }
  set
  {
   m_bDayLimit = value;
  }
 }
 ///
/// Day limit restriction
 ///
 public DateTime [] DateLimitFrom
 {
  get
  {
   return m_dtDateLimitFrom;
  }
  set
  {
   m_dtDateLimitFrom = value;
  }
 }

 ///


/// Day limit restriction
 ///
 public DateTime [] DateLimitTo
 {
  get
  {
   return m_dtDateLimitTo;
  }
  set
  {
   m_dtDateLimitTo = value;
  }
 }
}

public class TaskManager
{
 // Task list
 private System.Collections.Generic.List m_TaskManager;
    private DateTime m_dtLastTasksLoad = DateTime.Now;
    private DataTable dtTasks;

 public TaskManager()
 {
     m_TaskManager = new System.Collections.Generic.List();
 }

///


 /// Load tasks from DB
 ///
 /// is it reload task from database or first METHOD CALL
 public void LoadTasks(bool bReload)
 {
  if ( bReload == false )
  {
   m_TaskManager = new System.Collections.Generic.List();
  }

  bool bItemExists = false;

  try
  {
   // Load tasks from DB
   dtTasks = new DataTable();
   dtTasks.ReadXml(System.Windows.Forms.Application.StartupPath + "\\Tasks.xml");
   Task task = null;

       
   // for each task
   foreach ( DataRow row in dtTasks.Rows )
   {
    bItemExists = false;
    int iSchedulerTask_Id = Fnc.NL(row["schedulertask_id"],-1);
    if ( bReload == true )
    {
     foreach ( Task taskExisting in m_TaskManager )
     {
      if ( taskExisting.SchedulerTaskID == iSchedulerTask_Id )
      {
       task = taskExisting;
       bItemExists = true;
       break;
      }
     }
    }
    if ( bItemExists == false )
    {
     task = this.GetTask( Fnc.NL(row["task_uid"],""));
    }

  // not known task ID  (task_uid)
    if ( task == null ) continue;

    task.SchedulerTaskID = Fnc.NL(row["SchedulerTask_Id"], Const.NULL);
    task.TaskType = (ScheduleTaskEnum) Fnc.NL(row["Task_ScheduleType"],Const.NULL);
    task.Active  = Fnc.NL(row["active_task"], true);

                // by first load we read last exec time from DB
    if (bReload == false)
   {
       task.LastProcessTime = Fnc.NL(row["LastExecTime"], task.LastProcessTime);
    }

    // INTERVAL TASK
    if ( task.TaskType == ScheduleTaskEnum.SCHEDULER_TASK_INTERVAL )
    {
      task.TaskInterval  = Fnc.NL(row["Task_Interval_Sec"],Const.NULL);
      task.Task_UID      = Fnc.NL(row["Task_UID"], Const.NULLSTR);
    }
  // EXACT TIME
    else if ( task.TaskType == ScheduleTaskEnum.SCHEDULER_TASK_TIME )
    {
     DateTime dt = Fnc.NL(row["Task_Time"],Const.EMPTYDT);
     dt = new DateTime(1999, 1, 1, dt.Hour, dt.Month, dt.Second);
    if ( bReload == true )
     {
           if (task.TaskTime.Hour != dt.Hour || task.TaskTime.Minute != dt.Minute)
   {
      task.ClearState();
   }
     }
     task.TaskTime = dt;
     task.Task_UID = Fnc.NL(row["Task_UID"], Const.NULLSTR);
     if (bReload == true)
     {
         task.LastProcessTime = Fnc.NL(row["LastExecTime"], task.LastProcessTime);
     }

   }
   else if (task.TaskType == ScheduleTaskEnum.SCHEDULER_TASK_ONETIME)
   {
     task.TaskTime = Fnc.NL(row["Task_Time"],Const.EMPTYDT);
     task.Task_UID = Fnc.NL(row["Task_UID"], Const.NULLSTR);
}
   
    string strVal = "";
    bool bVal = false;
    DateTime dtVal;

    for ( int i = 1; i <= 7; i++)
    {
     // Day ( boolean )
     strVal = String.Format("Day{0}_Limit",i);
     bVal   = Fnc.NL(row[strVal],false);
     task.DayLimit[i-1] = bVal;

     // Day[i]_From
     strVal = String.Format("Day{0}_From",i);
     dtVal  = Fnc.NL(row[strVal],Const.EMPTYDT);
     dtVal = new DateTime(1999, 1, 1, dtVal.Hour, dtVal.Minute, dtVal.Second);
     task.DateLimitFrom[i-1] = dtVal;

     // Day[i]_From
    strVal = String.Format("Day{0}_To",i);
     dtVal = Fnc.NL(row[strVal], Const.EMPTYDT);
    dtVal = new DateTime(1999, 1, 1, dtVal.Hour, dtVal.Minute, dtVal.Second);
     task.DateLimitTo[i-1] = dtVal;
    }
    m_TaskManager.Add(task);
   }

  }
  catch (Exception ex )
  {
            Console.WriteLine(ex.ToString());
  }

 }

   
///


 /// Returns Task instance for specified parameter
 ///
 /// Parametr určující typ úlohy (L=Libory atp.)
 ///
 private Task GetTask(string strTaskUID)
 {
    switch (strTaskUID)
  {
            case "FirstTask":
                return new Tasks.FirstTask();
            case "SecondTask":
                return new Tasks.SecondTask();
            default:
    return null;
  }
 }
///
 /// Task check
 ///
 public void CheckTasks()
 {
        // for each 5 minutes we will refresh data from database
        if (DateTime.Now.Minute % 5 == 0 && m_dtLastTasksLoad.Minute != DateTime.Now.Minute)
        {
            m_dtLastTasksLoad = DateTime.Now;
            this.LoadTasks(true);
        }

  DateTime dtNow = DateTime.Now;
  TimeSpan sp;
  foreach (Task task in this.m_TaskManager )
  {
   // Interval task
   if ( task.TaskType == ScheduleTaskEnum.SCHEDULER_TASK_INTERVAL )
   {

    // number of seconds from last exec
    sp = dtNow - task.LastProcessTime;
    if ( sp.TotalSeconds > task.TaskInterval )
    {
     // Day limit
     int intDayOfWeek = (int)dtNow.DayOfWeek;
     intDayOfWeek--;
     // Sunday has position 6
     if ( intDayOfWeek == -1 ) intDayOfWeek = 6;
     // if there is a restriction for this day...
     if ( task.DayLimit[intDayOfWeek] == true )
     {
      DateTime dtNowSpec = new DateTime(1999,1,1, dtNow.Hour, dtNow.Minute, dtNow.Second);
      // Check limits
      if ( task.DateLimitFrom[intDayOfWeek] >= dtNowSpec )
       continue; // Get next task

      if ( task.DateLimitTo[intDayOfWeek] <= dtNowSpec )
       continue; // Get next task
     }
    try
     {
      // OK Run task
      task.LastProcessTime = DateTime.Now;
      task.DoIt();
     }
     catch(Exception ex) 
     {  
      ExceptionManager.SetException(ex,"CheckTasks");
     } 
    }
   }
   else if ( task.TaskType == ScheduleTaskEnum.SCHEDULER_TASK_TIME )
   {
    DateTime dtNowDate = new DateTime(1999, 1, 1, DateTime.Now.Hour, DateTime.Now.Month, DateTime.Now.Second);
    if (  task.LastProcessTime.Day != DateTime.Now.Day && dtNowDate >= task.TaskTime)
    {
     int dow = Convert.ToInt32(dtNow.DayOfWeek); // Day limit
     // move ( we have array from 0 )
     dow--;
    // Sunday has position 6
     if ( dow == -1 ) dow = 6;
    // if there is a restriction for this day...
     if ( task.DayLimit[dow] == true )
     {
      DateTime dtNowSpec = new DateTime(1999,1,1, dtNow.Hour, dtNow.Minute, dtNow.Second);
      // Check limits
      if ( task.DateLimitFrom[dow] >= dtNowSpec )
          continue; // Get next task
      if ( task.DateLimitTo[dow] <= dtNowSpec )
        continue; // Get next task
  
     }
     try
     {
     task.DoIt();
     }
     catch(Exception ex) 
     {  
      ExceptionManager.SetException(ex,"CheckTasks");
     } 
    }
   }
  }
 }

}

  Na stránku 
screen  Nový příspěvek
Název  Uživatel  Datum 
Poslední návštěva: 14:29:49, 21. listopadu 2017 První  Předchozí  0 Záznamů  Další  Poslední  

Autor článku
Jméno
Pracovní pozice
Informace
Foto

   

Počet návštěvníků:10
 
  Kontakt