[InlineData(30000)] // 30s
public void TimerElapsedIsRoughlyEquivalentToInterval(int interval)
{
const double permittedProportionUnder = -0.1;
const double permittedProportionOver = 0.5;
var elapsed = new AutoResetEvent(false);
IntPtr timer = IntPtr.Zero;
var stopwatch = new Stopwatch();
TimerElapsedEventHandler handler = (sender, args) =>
{
if (args?.TimerId == timer)
{
stopwatch.Stop();
elapsed.Set();
}
};
SystemEvents.TimerElapsed += handler;
try
{
timer = SystemEvents.CreateTimer(interval);
stopwatch.Start();
Assert.True(elapsed.WaitOne(interval * SystemEventsTest.ExpectedEventMultiplier));
var proportionDifference = (double)(stopwatch.ElapsedMilliseconds - interval) / interval;
Assert.True(permittedProportionUnder < proportionDifference && proportionDifference < permittedProportionOver,
$"Timer should fire less than {permittedProportionUnder * 100.0}% before and less than {permittedProportionOver * 100.0}% after expected interval {interval}, actual: {stopwatch.ElapsedMilliseconds}, difference: {proportionDifference * 100.0}%");
}
finally
{
SystemEvents.TimerElapsed -= handler;
SystemEvents.KillTimer(timer);
}
}
public void ConcurrentTimers()
{
const int NumConcurrentTimers = 10;
var timersSignalled = new Dictionary <IntPtr, bool>();
int numSignaled = 0;
var elapsed = new AutoResetEvent(false);
TimerElapsedEventHandler handler = (sender, args) =>
{
bool signaled = false;
lock (timersSignalled)
{
if (timersSignalled.TryGetValue(args.TimerId, out signaled) && !signaled)
{
timersSignalled[args.TimerId] = true;
if (Interlocked.Increment(ref numSignaled) == NumConcurrentTimers)
{
elapsed.Set();
}
}
}
};
SystemEvents.TimerElapsed += handler;
try
{
if (PlatformDetection.IsFullFramework)
{
// desktop has a bug where it will allow EnsureSystemEvents to proceed without actually creating the HWND
SystemEventsTest.WaitForSystemEventsWindow();
}
for (int i = 0; i < NumConcurrentTimers; i++)
{
lock (timersSignalled)
{
timersSignalled[SystemEvents.CreateTimer(TimerInterval)] = false;
}
}
Assert.True(elapsed.WaitOne(TimerInterval * SystemEventsTest.ExpectedEventMultiplier));
lock (timersSignalled)
{
foreach (var timer in timersSignalled.Keys.ToArray())
{
Assert.True(timersSignalled[timer]);
SystemEvents.KillTimer(timer);
}
}
}
finally
{
SystemEvents.TimerElapsed -= handler;
elapsed.Dispose();
}
}
/// <summary>
/// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
/// <example>
/// timerelapsedeventhandler.BeginInvoke(sender, e, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginInvoke(this TimerElapsedEventHandler timerelapsedeventhandler, Object sender, TimerElapsedEventArgs e, AsyncCallback callback)
{
if (timerelapsedeventhandler == null)
{
throw new ArgumentNullException("timerelapsedeventhandler");
}
return(timerelapsedeventhandler.BeginInvoke(sender, e, callback, null));
}
public void TimerElapsed()
{
TimerElapsedEventHandler handler = Elapsed;
if (handler != null)
{
handler(ControlId, txtName.Text, txtText.Text);
}
}
public void ConcurrentTimers()
{
const int NumConcurrentTimers = 10;
var timersSignaled = new ConcurrentDictionary <IntPtr, bool>();
int numSignaled = 0;
var elapsed = new ManualResetEventSlim();
TimerElapsedEventHandler handler = (sender, args) =>
{
// A timer might fire more than once. When it fires the first time, track it by adding
// it to a set and then increment the number of timers that have ever fired. When all
// timers have fired, set the event.
if (timersSignaled.TryAdd(args.TimerId, true) &&
Interlocked.Increment(ref numSignaled) == NumConcurrentTimers)
{
elapsed.Set();
}
};
SystemEvents.TimerElapsed += handler;
try
{
if (PlatformDetection.IsFullFramework)
{
// netfx has a bug where it will allow EnsureSystemEvents to proceed without actually creating the HWND
SystemEventsTest.WaitForSystemEventsWindow();
}
// Create all the timers
var timers = new List <IntPtr>();
for (int i = 0; i < NumConcurrentTimers; i++)
{
timers.Add(SystemEvents.CreateTimer(TimerInterval));
}
// Wait for them all to fire
Assert.True(elapsed.Wait(TimerInterval * SystemEventsTest.ExpectedEventMultiplier));
// Delete them all
foreach (IntPtr timer in timers)
{
Assert.True(timersSignaled.TryGetValue(timer, out _));
SystemEvents.KillTimer(timer);
}
}
finally
{
SystemEvents.TimerElapsed -= handler;
elapsed.Dispose();
}
}
public void TimerElapsedSignaled()
{
var elapsed = new AutoResetEvent(false);
object elapsedSender = null;
IntPtr timer = IntPtr.Zero;
TimerElapsedEventHandler handler = (sender, args) =>
{
if (args?.TimerId == timer)
{
elapsedSender = sender;
elapsed.Set();
}
};
SystemEvents.TimerElapsed += handler;
try
{
if (PlatformDetection.IsFullFramework)
{
// desktop has a bug where it will allow EnsureSystemEvents to proceed without actually creating the HWND
SystemEventsTest.WaitForSystemEventsWindow();
}
timer = SystemEvents.CreateTimer(TimerInterval);
Assert.True(elapsed.WaitOne(TimerInterval * SystemEventsTest.ExpectedEventMultiplier));
Assert.IsType <SystemEvents>(elapsedSender);
// Timer should fire more than once
Assert.True(elapsed.WaitOne(TimerInterval * SystemEventsTest.ExpectedEventMultiplier));
SystemEvents.KillTimer(timer);
elapsed.Reset();
// Timer should not fire once killed
Assert.False(elapsed.WaitOne(TimerInterval * SystemEventsTest.UnexpectedEventMultiplier));
}
finally
{
SystemEvents.TimerElapsed -= handler;
elapsed.Dispose();
}
}
public void ConcurrentTimers()
{
const int NumConcurrentTimers = 10;
var timersSignalled = new Dictionary <IntPtr, bool>();
int numSignaled = 0;
var elapsed = new AutoResetEvent(false);
TimerElapsedEventHandler handler = (sender, args) =>
{
bool signaled = false;
if (timersSignalled.TryGetValue(args.TimerId, out signaled) && !signaled)
{
timersSignalled[args.TimerId] = true;
if (Interlocked.Increment(ref numSignaled) == NumConcurrentTimers)
{
elapsed.Set();
}
}
};
SystemEvents.TimerElapsed += handler;
try
{
for (int i = 0; i < NumConcurrentTimers; i++)
{
timersSignalled[SystemEvents.CreateTimer(TimerInterval)] = false;
}
Assert.True(elapsed.WaitOne(TimerInterval * SystemEventsTest.ExpectedEventMultiplier));
foreach (var timer in timersSignalled.Keys.ToArray())
{
Assert.True(timersSignalled[timer]);
SystemEvents.KillTimer(timer);
}
}
finally
{
SystemEvents.TimerElapsed -= handler;
elapsed.Dispose();
}
}
public void TimerElapsedSignaled()
{
var elapsed = new AutoResetEvent(false);
object elapsedSender = null;
IntPtr timer = IntPtr.Zero;
TimerElapsedEventHandler handler = (sender, args) =>
{
if (args?.TimerId == timer)
{
elapsedSender = sender;
elapsed.Set();
}
};
SystemEvents.TimerElapsed += handler;
try
{
timer = SystemEvents.CreateTimer(TimerInterval);
Assert.True(elapsed.WaitOne(TimerInterval * SystemEventsTest.ExpectedEventMultiplier));
Assert.IsType <SystemEvents>(elapsedSender);
// Timer should fire more than once
Assert.True(elapsed.WaitOne(TimerInterval * SystemEventsTest.ExpectedEventMultiplier));
SystemEvents.KillTimer(timer);
elapsed.Reset();
// Timer should not fire once killed
Assert.False(elapsed.WaitOne(TimerInterval * SystemEventsTest.UnexpectedEventMultiplier));
}
finally
{
SystemEvents.TimerElapsed -= handler;
elapsed.Dispose();
}
}
/// <summary>
/// Register a function to be called when timer elapsed.
/// </summary>
/// /// <param name="onTimerElapsed">The TimerElapsedEventHandler function registering the flight event.</param>
public void RegisterToTimerElapsedEvent(TimerElapsedEventHandler onTimerElapsed)
{
TimerEventHandler += onTimerElapsed;
}
public static void add_TimerElapsed(TimerElapsedEventHandler value)
{
}
public static void remove_TimerElapsed(TimerElapsedEventHandler value)
{
}
public static void add_TimerElapsed (TimerElapsedEventHandler value) {
}
public static void remove_TimerElapsed (TimerElapsedEventHandler value) {
}
