wasSharp – Diff between revs 25 and 27

Subversion Repositories:
Rev:
Only display areas with differences – Ignore whitespace
Rev 25 Rev 27
1 /////////////////////////////////////////////////////////////////////////// 1 ///////////////////////////////////////////////////////////////////////////
2 // Copyright (C) Wizardry and Steamworks 2013 - License: GNU GPLv3 // 2 // Copyright (C) Wizardry and Steamworks 2013 - License: GNU GPLv3 //
3 // Please see: http://www.gnu.org/licenses/gpl.html for legal details, // 3 // Please see: http://www.gnu.org/licenses/gpl.html for legal details, //
4 // rights of fair usage, the disclaimer and warranty conditions. // 4 // rights of fair usage, the disclaimer and warranty conditions. //
5 /////////////////////////////////////////////////////////////////////////// 5 ///////////////////////////////////////////////////////////////////////////
6   6  
7 using System; 7 using System;
8 using System.Threading; 8 using System.Threading;
9 using System.Threading.Tasks; 9 using System.Threading.Tasks;
10   10  
11 namespace wasSharp.Timers 11 namespace wasSharp.Timers
12 { 12 {
13 public class Timer : IDisposable 13 public class Timer : IDisposable
14 { 14 {
15 private readonly Task CompletedTask = Task.FromResult(false); 15 private readonly Task CompletedTask = Task.FromResult(false);
16 private Task Delay; 16 private Task Delay;
17 private bool Disposed; 17 private bool Disposed;
18   18  
19 private CancellationTokenSource tokenSource; 19 private CancellationTokenSource tokenSource;
20   20  
21 public Timer() 21 public Timer()
22 { 22 {
23 } 23 }
24   24  
25 public Timer(Action callback, TimeSpan dueTime, TimeSpan period) : this() 25 public Timer(Action callback, TimeSpan dueTime, TimeSpan period) : this()
26 { 26 {
27 Callback = callback; 27 Callback = callback;
28 DueTime = dueTime; 28 DueTime = dueTime;
29 Period = period; 29 Period = period;
30   30  
31 Start(); 31 Start();
32 } 32 }
33   33  
34 public Timer(Action callback, int dueTime, int period) 34 public Timer(Action callback, int dueTime, int period)
35 : this(callback, TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period)) 35 : this(callback, TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period))
36 { 36 {
37 } 37 }
38   38  
39 public Timer(Action callback) : this(callback, TimeSpan.Zero, TimeSpan.Zero) 39 public Timer(Action callback) : this(callback, TimeSpan.Zero, TimeSpan.Zero)
40 { 40 {
41 } 41 }
42   42  
43 public Timer(Action callback, double dueTime, int period) 43 public Timer(Action callback, double dueTime, int period)
44 : this(callback, TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period)) 44 : this(callback, TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period))
45 { 45 {
46 } 46 }
47   47  
48 public Timer(Action callback, uint dueTime, uint period) 48 public Timer(Action callback, uint dueTime, uint period)
49 : this(callback, TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period)) 49 : this(callback, TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period))
50 { 50 {
51 } 51 }
52   52  
53 public Action Callback { set; get; } 53 public Action Callback { set; get; }
54   54  
55 public TimeSpan DueTime { get; set; } = TimeSpan.Zero; 55 public TimeSpan DueTime { get; set; } = TimeSpan.Zero;
56   56  
57 public TimeSpan Period { get; set; } = TimeSpan.Zero; 57 public TimeSpan Period { get; set; } = TimeSpan.Zero;
58   58  
59 public DateTime ScheduledTime 59 public DateTime ScheduledTime
60 { 60 {
61 get; 61 get;
62 set; 62 set;
63 } 63 }
64   64  
65 public void Dispose() 65 public void Dispose()
66 { 66 {
67 // Stop the timer. 67 // Stop the timer.
68 Stop(); 68 Stop();
69   69  
70 // Dispose the token. 70 // Dispose the token.
71 if (tokenSource != null) 71 if (tokenSource != null)
72 { 72 {
73 tokenSource.Cancel(); 73 tokenSource.Cancel();
74 tokenSource.Dispose(); 74 tokenSource.Dispose();
75 tokenSource = null; 75 tokenSource = null;
76 } 76 }
77   77  
78 // Set the disposed flag. 78 // Set the disposed flag.
79 Disposed = true; 79 Disposed = true;
80 } 80 }
81   81  
82 private void Start() 82 private void Start()
83 { 83 {
84 // Check if we have an installed callback and that there is at least a due time. 84 // Check if we have an installed callback and that there is at least a due time.
85 if (Callback == null || DueTime.Equals(TimeSpan.Zero)) 85 if (Callback == null || DueTime.Equals(TimeSpan.Zero))
86 return; 86 return;
87   87  
88 // Dispose the previous token source. 88 // Dispose the previous token source.
89 if (tokenSource != null) 89 if (tokenSource != null)
90 { 90 {
91 tokenSource.Cancel(); 91 tokenSource.Cancel();
92 tokenSource.Dispose(); 92 tokenSource.Dispose();
93 tokenSource = null; 93 tokenSource = null;
94 } 94 }
95   95  
96 // Create a new cancellation source. 96 // Create a new cancellation source.
97 tokenSource = new CancellationTokenSource(); 97 tokenSource = new CancellationTokenSource();
98   98  
99 Action tick = null; 99 Action tick = null;
100   100  
101 tick = () => 101 tick = () =>
102 { 102 {
103 Task.Run(Callback, tokenSource.Token); 103 Task.Run(Callback, tokenSource.Token);
104 if (Disposed) 104 if (Disposed)
105 return; 105 return;
106 switch (!Period.Equals(TimeSpan.Zero)) 106 switch (!Period.Equals(TimeSpan.Zero))
107 { 107 {
108 case true: 108 case true:
109 ScheduledTime = DateTime.UtcNow; 109 ScheduledTime = DateTime.UtcNow;
110 Delay = Task.Delay(DueTime, tokenSource.Token); 110 Delay = Task.Delay(DueTime, tokenSource.Token);
111 break; 111 break;
-   112  
112 default: 113 default:
113 Delay = CompletedTask; 114 Delay = CompletedTask;
114 break; 115 break;
115 } 116 }
116 if (Disposed || Delay.IsCompleted) 117 if (Disposed || Delay.IsCompleted)
117 return; 118 return;
118 Delay.ContinueWith(o => tick(), tokenSource.Token); 119 Delay.ContinueWith(o => tick(), tokenSource.Token);
119 }; 120 };
120   121  
121 switch (!DueTime.Equals(TimeSpan.Zero)) 122 switch (!DueTime.Equals(TimeSpan.Zero))
122 { 123 {
123 case true: 124 case true:
124 ScheduledTime = DateTime.UtcNow; 125 ScheduledTime = DateTime.UtcNow;
125 Delay = Task.Delay(DueTime, tokenSource.Token); 126 Delay = Task.Delay(DueTime, tokenSource.Token);
126 break; 127 break;
-   128  
127 default: 129 default:
128 Delay = CompletedTask; 130 Delay = CompletedTask;
129 break; 131 break;
130 } 132 }
131 if (Disposed || Delay.IsCompleted) 133 if (Disposed || Delay.IsCompleted)
132 return; 134 return;
133 Delay.ContinueWith(o => tick(), tokenSource.Token); 135 Delay.ContinueWith(o => tick(), tokenSource.Token);
134 } 136 }
135   137  
136 public void Change(int dueTime, int period) 138 public void Change(int dueTime, int period)
137 { 139 {
138 Change(TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period)); 140 Change(TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period));
139 } 141 }
140   142  
141 public void Change(uint dueTime, int period) 143 public void Change(uint dueTime, int period)
142 { 144 {
143 Change(TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period)); 145 Change(TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period));
144 } 146 }
145   147  
146 public void Change(TimeSpan dueTime, TimeSpan period) 148 public void Change(TimeSpan dueTime, TimeSpan period)
147 { 149 {
148 DueTime = dueTime; 150 DueTime = dueTime;
149 Period = period; 151 Period = period;
150   152  
151 Start(); 153 Start();
152 } 154 }
153   155  
154 public void Stop() 156 public void Stop()
155 { 157 {
156 Change(0, 0); 158 Change(0, 0);
157 } 159 }
158 } 160 }
159 } -  
160   161 }
-   162  
161
Generated by GNU Enscript 1.6.5.90.
 -  
162   -  
163   -  
164   -