自定義定時組件

本文轉載自查看原文 2014-08-15 07:33 1128 C#

　　工作了這么久，封裝過一部分Helper，也寫過一些控件，但也沒寫過屬於自己的框架，這次寫的這個我覺得是一個組件而已，是一個定時組件。是一個定時器組件，有別於.NET Framework里面提供的幾個Timer。首先說說背景，就發現現在手頭上的工作離不開定時，定時做一個任務，什么都是定時去做什么什么，隔某段時間干某件事情，都離不開“定時”這個詞。眾所周知這個要用到多線程，在多篇關於多線程的文章里面有提過做一些周期性的操作時最好用Timer，當然這個Timer肯定是Threading.Timer，並不是WinForm控件里面的Timer。但我覺得在我的應用中Timer不夠滿足需求。

1.Timer只能在做任務與任務之間相隔一段時間的操作，如下圖

但我需要的是這次任務開始的時刻到下次任務開始時刻是相隔同等的時間，又如下圖

這樣的情況下Timer則不能滿足需求。

2.Timer的時間間隔一般是定的，但是如果要每次執行完任務要變動一下休眠的時間，則需要調用Timer的Change方法。

3.Timer的休眠時間不是通過整形確定休眠的毫秒數，就是用一個TimeSpan來確定，對於那種到每天多少多少時刻或者到每小時的多少分執行一次的任務來說也不能夠完全方便使用

對於上面這三種，鄙人對定時器封裝了一下，棄用了Timer，還是用回了原有的Thread，定義了一種描述重復時間的模式字符串，計算出TimeSpan，從而調用Thread的Sleep()方法來休眠。下面展示整個組件的類圖

最底下是兩個關於時間計算方面的類，兩個代理是兩種任務方法的委托，基類BaseCycleMission是周期任務的積累，實現了ICycle接口，主要進行對任務線程的操控（開始，停止等），繼承他的兩個子類一個是實現上文第一點中我后來描述那種需求，一個類似於原有Timer的功能。它們各自使用不同的委托。MissionManager只是對所有周期任務的一個管理，統一去開啟或暫停某一類的任務。

時間計算模塊

　　那首先來介紹一下定義的字符串模式。現在遇到的周期是有兩種模式，

一種是每隔多長時間要執行一次的任務，這個是最普通的周期形式，以每個5分鍾為例，完整的形式是“-99--99--99 -99:05:00”，“-99”是缺省的意思，當然還有其他簡寫的模式；
另一種是沒到什么什么時候執行一次任務，例如沒到中午12點為例完整的形式是“ff-ff-ff 12: ff:ff”，“ff”是默認的形式，當然也可以用“FF”，這里也有其他簡寫的模式。

所有字符串的模式如下表所示

	每到***時刻	每隔***時間
完整	ffff-ff-ff ff:ff:ff 或 ff-ff-ff ff:ff:ff	-99--99--99 -99:-99:-99
日期部分	ffff-ff-ff 或 ff-ff-ff	-99--99--99
時間部分	ff:ff:ff 或 ff:ff:ff	-99:-99:-99
時間簡寫	ff:ff 或 ff:ff	-99:-99

　　那么時間計算模塊的處理流程是，給定了相應的模式字符串，TimePointConverter借助正則表達式匹配出對應的模式，返回匹配出來的年月日時分秒各個值，得出結果之后就調用SleepTimeProvider來計算出線程所要休眠的時間。下面則展示一下兩個類的部分代碼

 1     public class TimePointConverter
 2     {
 3         //其他成員
 4         private int[] DateTimeFixBuilder(string timeStr)
 5         {
 6             int[] result = null;
 7 
 8             string[] dtArray = timeStr.Split();
 9             string[] dateArray = dtArray[0].Split('-');
10             string[] timeArray = dtArray[1].Split(':');
11 
12             uint year,month,date;
13             uint hour, minute, second; 
14             uint.TryParse(dateArray[0], out year);
15             uint.TryParse(dateArray[1], out month);
16             uint.TryParse(dateArray[2], out date);
17 
18             uint.TryParse(timeArray[0], out hour);
19             uint.TryParse(timeArray[1], out minute);
20             uint.TryParse(timeArray[2], out second);
21 
22             //return InnerFixBuilder(year, month, date, hour, minute, second);
23             result = new int[] { (int)year, (int)month, (int)date, (int)hour, (int)minute, (int)second };
24             return result;
25         }
26         //其他成員
27     }

 1     public class SleepTimeProvider
 2 {
 3         //其他成員
 4         public TimeSpan InnerFixBuilder(uint year, uint month, uint date, uint hour, uint minute, uint second)
 5                 {
 6             uint[] uintTimeArray = new uint[6] { year, month, date, hour, minute, second };
 7             int[] intNowArray = new int[6] 
 8             {   
 9                 DateTime.Now.Year,DateTime.Now.Month,DateTime.Now.Day,
10                 DateTime.Now.Hour,DateTime.Now.Minute,DateTime.Now.Second 
11             };
12             int[] intTimeArray = new int[6];
13 
14             intTimeArray[0] = uintTimeArray[0] == 0 ? -DateTime.Now.Year : (int)uintTimeArray[0];
15             for (int i = 1; i < uintTimeArray.Length; i++)
16             {
17                 intTimeArray[i] = intTimeArray[i - 1] < 0 && uintTimeArray[i] == 0 ?
18                     -intNowArray[i] : (int)uintTimeArray[i];
19             }
20             DateTime goalTime = new DateTime(Math.Abs(intTimeArray[0]),
21                 Math.Abs(intTimeArray[1]),
22                 Math.Abs(intTimeArray[2]),
23                 Math.Abs(intTimeArray[3]),
24                 Math.Abs(intTimeArray[4]),
25                 Math.Abs(intTimeArray[5]));
26 
27 
28             if (goalTime < DateTime.Now)
29             {
30                 int max = -1;
31                 for (int i = intTimeArray.Length - 1; i >= 0; i--)
32                 {
33                     if (intTimeArray[i] < 0 && i > max)
34                     {
35                         max = i;
36                         intTimeArray[i]--;
37                     }
38                     intTimeArray[i] = Math.Abs(intTimeArray[i]);
39                 }
40                 goalTime = new DateTime(Math.Abs(intTimeArray[0]),
41                 Math.Abs(intTimeArray[1]),
42                 Math.Abs(intTimeArray[2]),
43                 Math.Abs(intTimeArray[3]),
44                 Math.Abs(intTimeArray[4]),
45                 Math.Abs(intTimeArray[5]));
46             }
47             return goalTime - DateTime.Now;
48         }
49 
50         //其他成員
51 }

線程調用模塊

　　線程調用模塊是任務執行的核心部分，MissionEntiy是對線程操作的封裝，主要負責開始，停止，暫停等操作。Thread用的是后台線程，對線程操作時也多做幾個判斷。例如暫停那個操作的定義如下

 1         public bool Pause()
 2         {
 3             if (actionThread == null) return false;
 4             if (actionThread.ThreadState == (System.Threading.ThreadState.Running | ThreadState.Background) ||
 5                 actionThread.ThreadState == (System.Threading.ThreadState.WaitSleepJoin | ThreadState.Background))
 6             {
 7                 actionThread.Suspend();
 8                 return true;
 9             }
10             return false;
11         }

　　CycleMission是真正的任務載體，里面都同樣有對線程的操作，但是又外加了一些時間處理，最核心的是讓線程的BuildMainAction方法，這個方法是計算出要休眠的時間，讓線程休眠，到點時調用適當的方法委托。

  1     public class BaseCycleMission:ICycleMission
  2     {
  3         //其他成員
  4 
  5         protected void BuildMainAction(string normalCycle, string overTimeCycle, object overTimeDelegate, bool isSleepBefore, bool isInclude)
  6         {
  7             mainAction = () =>
  8             {
  9                 TimeSpan sleepTime = TimeSpan.MinValue;
 10                 TimeSpan overTime = TimeSpan.MinValue;
 11                 bool result = true;
 12                 TimePointConvert.CircleType type;
 13 
 14                 #region 提前休眠
 15                 if (isSleepBefore)
 16                 {
 17                     type = TimePointConvert.Default.PraseType(normalCycle);
 18 
 19                     if (type == TimePointConvert.CircleType.Interval)
 20                         sleepTime = SleepTimeProvider.Defult.InnerIntervalBuilder(
 21                             TimePointConvert.Default.ConvertCircle(normalCycle));
 22                     else
 23                         sleepTime = SleepTimeProvider.Defult.InnerFixBuilder(
 24                         TimePointConvert.Default.ConvertCircle(normalCycle));
 25                     if (sleepTime.TotalMilliseconds > 0)
 26                         Thread.Sleep(sleepTime);
 27                 }
 28                 #endregion
 29 
 30                 while (true)
 31                 {
 32                     #region 計算時間
 33                     if (isInclude)
 34                     {
 35 
 36                         type = TimePointConvert.Default.PraseType(normalCycle);
 37 
 38                         sleepTime = type == TimePointConvert.CircleType.Interval ?
 39                             SleepTimeProvider.Defult.InnerIntervalBuilder(
 40                                 TimePointConvert.Default.ConvertCircle(normalCycle)) :
 41                             SleepTimeProvider.Defult.InnerFixBuilder(
 42                                 TimePointConvert.Default.ConvertCircle(normalCycle));
 43                         
 44 
 45                         type = TimePointConvert.Default.PraseType(overTimeCycle);
 46 
 47                         overTime = type == TimePointConvert.CircleType.Interval ?
 48                             SleepTimeProvider.Defult.InnerIntervalBuilder(
 49                                 TimePointConvert.Default.ConvertCircle(overTimeCycle)) :
 50                             SleepTimeProvider.Defult.InnerFixBuilder(
 51                                 TimePointConvert.Default.ConvertCircle(overTimeCycle));
 52 
 53                     }
 54                     #endregion
 55 
 56                     #region 執行方法
 57                     if (overTimeDelegate is OverTimeCycleDelegate)
 58                         result = (overTimeDelegate as OverTimeCycleDelegate).Invoke();
 59                     else
 60                     {
 61                         (overTimeDelegate as CycleDelegate).Invoke();
 62                         result = true;
 63                     }
 64                     #endregion
 65 
 66                     #region 計算時間
 67                     if (!isInclude)
 68                     {
 69 
 70 
 71                         type = TimePointConvert.Default.PraseType(normalCycle);
 72 
 73 
 74                         sleepTime = type == TimePointConvert.CircleType.Interval ?
 75                             SleepTimeProvider.Defult.InnerIntervalBuilder(
 76                                 TimePointConvert.Default.ConvertCircle(normalCycle)) :
 77                             SleepTimeProvider.Defult.InnerFixBuilder(
 78                                 TimePointConvert.Default.ConvertCircle(normalCycle));
 79 
 80                         type = TimePointConvert.Default.PraseType(overTimeCycle);
 81 
 82                         overTime = type == TimePointConvert.CircleType.Interval ?
 83                             SleepTimeProvider.Defult.InnerIntervalBuilder(
 84                                 TimePointConvert.Default.ConvertCircle(overTimeCycle)) :
 85                             SleepTimeProvider.Defult.InnerFixBuilder(
 86                                 TimePointConvert.Default.ConvertCircle(overTimeCycle));
 87                     }
 88                     #endregion
 89 
 90 
 91                     if (result)
 92                     {
 93                         if (sleepTime.TotalMilliseconds > 0)
 94                             Thread.Sleep(sleepTime);
 95                     }
 96                     else
 97                     {
 98                         if (overTime.TotalMilliseconds > 0)
 99                             Thread.Sleep(overTime);
100                     }
101                 }
102             };
103         }
104 
105         //其他成員
106     }

當然調用不是調用這個方法，調用只是調用它兩個幾類ExceptCycleMission和IncludeCycleMission，分別代表任務執行的時間不包括在周期里面和包括在周期里面兩種。

管理器部分

　　管理器主要是一個字典集，是一個ICycleMission和字符串的字典集，里面包含了對集合里面所有元素的操作：增加，刪除，運行，恢復，暫停，停止。除了刪除和增加，其他都包含了類似下面的方法

RunAllMission()
RunAllIncludeCycleMission()
RunAllExceptCycleMission()
RunMissionAmong(params string[] missionNames)
RunMissionExcept(params string[] missionNames)

但是這堆方法里面都調用了CallAction這個方法，

        private void CallAction(IEnumerable<ICycleMission> missionCollection,Action method)
        {
            if (missionCollection == null || method == null||missionCollection.Count()==0) return;
            
            foreach (ICycleMission item in missionCollection)
            {
                method.Method.Invoke(item, null);
            }
        }

例如在RunAllExceptCycleMission()方法里面調用如下

        public void RunAllExceptCycleMission()
        {
            CallAction(this.Values.Where(c => c is ExceptCycleMission), BaseCycleMission.Default.RunMission);
        }

　　做這個組件應該是小題大做，畢竟看了那么久的《MVC框架揭秘》手癢，寫了這個東西覺得框架里面的結構要設計好，命名也要命名好。

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 8、VUE自定義組件【ExtJS】關於自定義組件(一) ArkUI 自定義組件 Laya自定義組件關於自定義組件的組件命名規范 vue自定義抽屜組件 vue自定義組件及傳值 [UE4]自定義MovementComponent組件 Winform 自定義窗體皮膚組件 vue 自定義image組件