public static Original::Timer ___ctor_newobj(Original::TimerCallback tc, object state, uint dueTime, uint period)
{
return(Helper.SimpleWrap <Original::Timer>(
delegate(ClrSyncManager manager) { return TimerHelpers.CreateTimer(manager, tc, state, new TimeSpan(dueTime), new TimeSpan(period)); },
delegate() { return new Original::Timer(tc, state, dueTime, period); }
));
}
public static Timer CreateTimer(ClrSyncManager manager, Original::TimerCallback timerCallback, object state, TimeSpan dueTime, TimeSpan period)
{
TimerRoutineArg argument = new TimerRoutineArg();
argument.callback = timerCallback;
argument.state = state;
argument.dueTime = dueTime;
argument.Period = period;
argument.selfSemaphore = new Semaphore(0, 1);
argument.parentSemaphore = new Semaphore(0, 1);
argument.disposed = false;
argument.changed = true;
Timer ret = new Timer(TimerCreateWrapper, argument, 0, Timeout.Infinite);
argument.timer = ret;
timer2tra.Add(ret, argument);
int child = manager.TaskFork();
argument.parentSemaphore.WaitOne();
manager.RegisterTaskSemaphore(child, argument.selfSemaphore, false);
manager.TaskResume(child);
return(ret);
}
/* Use a TimerCallback delegate to specify the method you want the Timer to execute.
* The timer delegate is specified when the timer is constructed, and cannot be changed.
* The method does not execute on the thread that created the timer; it executes on a ThreadPool
* thread supplied by the system.
*
* When you create a timer, you can specify an amount of time to wait before the first execution
* of the method (due time), and an amount of time to wait between subsequent executions (period).
* You can change these values, or disable the timer, using the Change method.
*
* Note: As long as you are using a Timer, you must keep a reference to it. As with any managed object,
* a Timer is subject to garbage collection when there are no references to it. The fact that a Timer is
* still active does not prevent it from being collected.
*
* When a timer is no longer needed, use the Dispose method to free the resources held by the timer. To
* receive a signal when the timer is disposed, use the Dispose(WaitHandle) method overload that takes a
* WaitHandle. The WaitHandle is signaled when the timer has been disposed.
*
* The callback method executed by the timer should be reentrant, because it is called on ThreadPool threads.
* The callback can be executed simultaneously on two thread pool threads if the timer interval is less than
* the time required to execute the callback, or if all thread pool threads are in use and the callback is
* queued multiple times.
*
* Note: System.Threading.Timer is a simple, lightweight timer that uses callback methods and is served by
* threadpool threads. You might also consider System.Windows.Forms.Timer for use with Windows forms, and
* System.Timers.Timer for server-based timer functionality. These timers use events and have additional features.
*/
public static Original::Timer ___ctor_newobj(Original::TimerCallback tc)
{
return(Helper.SimpleWrap <Original::Timer>(
delegate(ClrSyncManager manager) { return TimerHelpers.CreateTimer(manager, tc, null, new TimeSpan(Timeout.Infinite),
new TimeSpan(Timeout.Infinite)); },
delegate() { return new Original::Timer(tc); }
));
}
public static Original::Timer ___ctor_newobj(Original::TimerCallback tc, object state, TimeSpan dueTime, TimeSpan period)
{
if (dueTime.TotalMilliseconds < 0 && dueTime.TotalMilliseconds != Timeout.Infinite)
{
throw new ArgumentOutOfRangeException();
}
if (period.TotalMilliseconds < 0 && period.TotalMilliseconds != Timeout.Infinite)
{
throw new ArgumentOutOfRangeException();
}
return(Helper.SimpleWrap <Original::Timer>(
delegate(ClrSyncManager manager) { return TimerHelpers.CreateTimer(manager, tc, state, dueTime, period); },
delegate() { return new Original::Timer(tc, state, dueTime, period); }
));
}
