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); } )); }
/* 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 VoiceChannelTrackerService(DiscordSocketClient discord, VoiceChannelTrackerSettings settings, ILogger <VoiceChannelTrackerService> logger) : base(discord) { _logger = logger; _discord = discord; _discord.GuildAvailable += InitailizeVoiceChannelTracker; _settings = settings; _clearOldMessagesInterval = TimerHelpers.SetTimeout(async() => { await DeleteOldMessages(); }, 120000, true); }
private async Task InitializeAsync() { _timer?.Stop(); _timer?.Dispose(); _timer = await TimerHelpers.SetTimeoutAsync(HandleCheckIntervalElapsedAsync, 10000, true, true); _discord.MessageReceived -= HandleMessageReceived; _discord.MessageReceived += HandleMessageReceived; }
private async Task StartNewBet(string maxValue) { if (!int.TryParse(maxValue, out var maxRollValue)) { return; } _currentRound = GamblingRound.CreateInstance(maxRollValue); await _gamblingChannel.SendMessageAsync($"New bet (Max roll value: {maxRollValue}) started. Type `!jb` to join this round. Starting in 15 seconds."); _awaitingRollsTimer = TimerHelpers.SetTimeout(async() => { await StartAwaitingRolls(); }, 15000); _rollRemindTimer = TimerHelpers.SetTimeout(async() => { await RemindRollers(); }, 30000); _roundTimeoutTimer = TimerHelpers.SetTimeout(async() => { await EndRound(); }, 45000); }
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); } )); }
private async Task InitializeRefreshCheckerAsync() { _refreshInterval = await TimerHelpers.SetTimeoutAsync(async() => { var previousLastRefresh = _lastEventUpdate; var events = await GetEventsAsync(); if (previousLastRefresh < _lastEventUpdate) { _refreshInterval.Stop(); _runningRefresh = false; await UpdateExistingEventEmbedAsync(events); } }, 10000, true); }
private async Task Start() { await TimerHelpers.SetTimeoutAsync(async() => { var sw = new Stopwatch(); sw.Start(); _logger.LogInformation("Getting applications."); var applications = await _neonApiService.GetApplicationListAsync(); if (applications != null) { _logger.LogInformation($"Getting {applications.Count()} applications took {sw.ElapsedMilliseconds} ms."); await CheckForNewApplications(applications); await CheckForOverdueApplications(applications); } }, 60000 * 2, true, true); _discord.MessageReceived -= HandleMessage; _discord.MessageReceived += HandleMessage; }
private async Task StartCheckingForChangesAsync() { _interval = await TimerHelpers.SetTimeoutAsync(CheckForChangeAsync, _settings.CheckInterval, true, true); }
private async Task InitializeServiceAsync() { _checkInterval = await TimerHelpers.SetTimeoutAsync(async() => { await CheckForNewMessagesAsync(); }, 60 * 1000 * 3, true, true); }
private async Task InitializeServiceAsync() { _checkInterval?.Stop(); _checkInterval?.Dispose(); _checkInterval = await TimerHelpers.SetTimeoutAsync(async() => { await CheckForNewTweetsAsync(); }, _settings.CheckIntervalSeconds * 1000, true, true); }