wasSharp

Subversion Repositories:
Compare Path: Rev
With Path: Rev
?path1? @ 19  →  ?path2? @ 20
/Timers/DecayingAlarm.cs
@@ -80,7 +80,7 @@
{
case true:
elapsed.Start();
alarm = new Timer(o =>
alarm = new Timer(() =>
{
lock (LockObject)
{
@@ -90,7 +90,7 @@
alarm.Dispose();
alarm = null;
}
}, null, (int) deadline, 0);
}, deadline, 0);
return;
case false:
elapsed.Stop();
/Timers/TimedThrottle.cs
@@ -29,13 +29,13 @@
EventsAllowed = events;
if (timer == null)
{
timer = new Timer(o =>
timer = new Timer(() =>
{
lock (LockObject)
{
TriggeredEvents = 0;
}
}, null, (int) seconds, (int) seconds);
}, seconds, seconds);
}
}
 
/Timers/Timer.cs
@@ -10,105 +10,107 @@
 
namespace wasSharp.Timers
{
public delegate void TimerCallback(object state);
 
public class Timer : IDisposable
{
private static readonly Task CompletedTask = Task.FromResult(false);
private readonly TimerCallback Callback;
private readonly object State;
private readonly Action callback;
private readonly Task CompletedTask = Task.FromResult(false);
private Task Delay;
private bool Disposed;
private int Period;
private CancellationTokenSource TokenSource;
private TimeSpan dueTime;
private TimeSpan period;
private CancellationTokenSource tokenSource;
 
public Timer(TimerCallback callback, object state, int dueTime, int period)
public Timer(Action callback, TimeSpan dueTime, TimeSpan period)
{
Callback = callback;
State = state;
Period = period;
Reset(dueTime);
this.callback = callback;
this.dueTime = dueTime;
this.period = period;
 
Run();
}
 
public Timer(TimerCallback callback, object state, TimeSpan dueTime, TimeSpan period)
: this(callback, state, (int) dueTime.TotalMilliseconds, (int) period.TotalMilliseconds)
public Timer(Action callback, int dueTime, int period)
: this(callback, TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period))
{
}
 
public Timer(TimerCallback callback) : this(callback, null, TimeSpan.Zero, TimeSpan.Zero)
public Timer(Action callback) : this(callback, TimeSpan.Zero, TimeSpan.Zero)
{
}
 
public void Dispose()
public Timer(Action callback, double dueTime, int period)
: this(callback, TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period))
{
Dispose(true);
GC.SuppressFinalize(this);
}
 
~Timer()
public Timer(Action callback, uint dueTime, uint period)
: this(callback, TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period))
{
Dispose(false);
}
 
private void Dispose(bool cleanUpManagedObjects)
public void Dispose()
{
if (cleanUpManagedObjects)
Cancel();
if (tokenSource != null)
{
tokenSource.Cancel();
tokenSource.Dispose();
tokenSource = null;
}
Disposed = true;
}
 
public void Change(int dueTime, int period)
private void Run()
{
Period = period;
Reset(dueTime);
}
// Cancel any previous timer.
if (tokenSource != null)
{
tokenSource.Cancel();
tokenSource.Dispose();
tokenSource = null;
}
 
public void Change(uint dueTime, int period)
{
Period = period;
Change((int) dueTime, period);
}
// Create a new cancellation source.
tokenSource = new CancellationTokenSource();
 
public void Change(TimeSpan dueTime, TimeSpan period)
{
Change((int) dueTime.TotalMilliseconds, (int) period.TotalMilliseconds);
}
 
private void Reset(int due)
{
Cancel();
if (due <= 0)
return;
TokenSource = new CancellationTokenSource();
Action tick = null;
tick = () =>
{
Task.Run(() => Callback(State));
Task.Run(() => callback(), tokenSource.Token);
if (Disposed)
return;
Delay = Period > 0 ? Task.Delay(Period, TokenSource.Token) : CompletedTask;
Delay = !period.Equals(0) ? Task.Delay(period, tokenSource.Token) : CompletedTask;
if (Delay.IsCompleted)
return;
Delay.ContinueWith(t => tick(), TokenSource.Token);
Delay.ContinueWith(t => tick(), tokenSource.Token);
};
Delay = due > 0 ? Task.Delay(due, TokenSource.Token) : CompletedTask;
 
Delay = !dueTime.Equals(0) ? Task.Delay(dueTime, tokenSource.Token) : CompletedTask;
if (Delay.IsCompleted)
return;
Delay.ContinueWith(t => tick(), TokenSource.Token);
Delay.ContinueWith(t => tick(), tokenSource.Token);
}
 
public void Stop()
public void Change(int dueTime, int period)
{
Change(0, 0);
Change(TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period));
}
 
private void Cancel()
public void Change(uint dueTime, int period)
{
if (TokenSource == null)
return;
TokenSource.Cancel();
TokenSource.Dispose();
TokenSource = null;
Change(TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period));
}
 
public void Change(TimeSpan dueTime, TimeSpan period)
{
this.dueTime = dueTime;
this.period = period;
 
Run();
}
 
public void Stop()
{
Change(0, 0);
}
}
}