/// <summary>
/// Schedules a periodic piece of work, using a System.Threading.Timer object.
/// </summary>
/// <typeparam name="TState">The type of the state passed to the scheduled action.</typeparam>
/// <param name="state">Initial state passed to the action upon the first iteration.</param>
/// <param name="period">Period for running the work periodically.</param>
/// <param name="action">Action to be executed, potentially updating the state.</param>
/// <returns>The disposable object used to cancel the scheduled recurring action (best effort).</returns>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="period"/> is less than TimeSpan.Zero.</exception>
/// <exception cref="ArgumentNullException"><paramref name="action"/> is null.</exception>
public IDisposable SchedulePeriodic <TState>(TState state, TimeSpan period, Func <TState, TState> action)
{
if (period < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException(nameof(period));
}
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
var state1 = state;
var gate = new AsyncLock();
var cancel = s_cal.StartPeriodicTimer(() =>
{
gate.Wait(() =>
{
state1 = action(state1);
});
}, period);
return(Disposable.Create(() =>
{
cancel.Dispose();
gate.Dispose();
action = Stubs <TState> .I;
}));
}
public void Dispose()
{
var timer = _timer;
if (timer != null)
{
_action = Stubs <TState> .I;
_timer = null;
timer.Dispose();
_gate.Dispose();
}
}
/// <summary>
/// Schedules a periodic piece of work, using a Windows.System.Threading.ThreadPoolTimer object.
/// </summary>
/// <typeparam name="TState">The type of the state passed to the scheduled action.</typeparam>
/// <param name="state">Initial state passed to the action upon the first iteration.</param>
/// <param name="period">Period for running the work periodically.</param>
/// <param name="action">Action to be executed, potentially updating the state.</param>
/// <returns>The disposable object used to cancel the scheduled recurring action (best effort).</returns>
/// <exception cref="ArgumentNullException"><paramref name="action"/> is null.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="period"/> is less than one millisecond.</exception>
public IDisposable SchedulePeriodic <TState>(TState state, TimeSpan period, Func <TState, TState> action)
{
// The WinRT thread pool is based on the Win32 thread pool and cannot handle
// sub-1ms resolution. When passing a lower period, we get single-shot
// timer behavior instead. See MSDN documentation for CreatePeriodicTimer
// for more information.
if (period < TimeSpan.FromMilliseconds(1))
{
throw new ArgumentOutOfRangeException(nameof(period), "The WinRT thread pool doesn't support creating periodic timers with a period below 1 millisecond.");
}
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
var state1 = state;
var gate = new AsyncLock();
WasmRuntime.ScheduleTimeout(
(int)period.TotalMilliseconds,
() =>
{
Action run = null;
run = () =>
{
gate.Wait(() =>
{
state1 = action(state1);
WasmRuntime.ScheduleTimeout(
(int)period.TotalMilliseconds,
run);
});
};
});
return(Disposable.Create(() =>
{
gate.Dispose();
action = Stubs <TState> .I;
}));
}
/// <summary>
/// Schedules a periodic piece of work, using a Windows.System.Threading.ThreadPoolTimer object.
/// </summary>
/// <typeparam name="TState">The type of the state passed to the scheduled action.</typeparam>
/// <param name="state">Initial state passed to the action upon the first iteration.</param>
/// <param name="period">Period for running the work periodically.</param>
/// <param name="action">Action to be executed, potentially updating the state.</param>
/// <returns>The disposable object used to cancel the scheduled recurring action (best effort).</returns>
/// <exception cref="ArgumentNullException"><paramref name="action"/> is null.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="period"/> is less than one millisecond.</exception>
public IDisposable SchedulePeriodic <TState>(TState state, TimeSpan period, Func <TState, TState> action)
{
//
// The WinRT thread pool is based on the Win32 thread pool and cannot handle
// sub-1ms resolution. When passing a lower period, we get single-shot
// timer behavior instead. See MSDN documentation for CreatePeriodicTimer
// for more information.
//
if (period < TimeSpan.FromMilliseconds(1))
{
throw new ArgumentOutOfRangeException(nameof(period), Strings_PlatformServices.WINRT_NO_SUB1MS_TIMERS);
}
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
var state1 = state;
var gate = new AsyncLock();
var res = global::Windows.System.Threading.ThreadPoolTimer.CreatePeriodicTimer(
tpt =>
{
gate.Wait(() =>
{
state1 = action(state1);
});
},
period
);
return(Disposable.Create(() =>
{
res.Cancel();
gate.Dispose();
action = Stubs <TState> .I;
}));
}
public void Dispose()
{
var l = new AsyncLock();
var l1 = false;
var l2 = false;
var l3 = false;
var l4 = false;
l.Wait(() =>
{
l.Wait(() =>
{
l.Wait(() =>
{
l3 = true;
});
l2 = true;
l.Dispose();
l.Wait(() =>
{
l4 = true;
});
});
l1 = true;
});
Assert.IsTrue(l1);
Assert.IsTrue(l2);
Assert.IsFalse(l3);
Assert.IsFalse(l4);
}
public void Dispose()
{
_cts.Cancel();
_gate.Dispose();
}
public void Dispose()
{
Disposable.TryDispose(ref _task);
_gate.Dispose();
}
public void Dispose()
{
_timer.Cancel();
_gate.Dispose();
_action = Stubs <TState> .I;
}
public void Dispose()
{
_cancel.Dispose();
_gate.Dispose();
_action = Stubs <TState> .I;
}