/// <summary> /// U idle modu prvo saljemo ENQ karakter i startamo timer /// Ukoliko uredjaj ne odovori timer handler ce se pozvati kad istekne timer /// </summary> /// <param name="protocol"></param> /// <param name="message"></param> public override void Send(Protocol protocol, string message) { log.DebugFormat("IdleState:Send:Message={0}",message); try { _message = message; _message_sent = true; protocol.SendEnq(); protocol.AckTimer.Interval = Timeout.NoResponseTimeOut; _timerHandler = new ElapsedEventHandler(bind<object, ElapsedEventArgs, Protocol>(TimeoutHandler, protocol)); protocol.AckTimer.Elapsed += _timerHandler; protocol.AckTimer.Start(); } catch (Exception ex) { log.Error(ex.ToString()); throw; } }
public Debouncer(double timeout_ms, ElapsedEventHandler action) { this.timeout_ms = timeout_ms; timer = new System.Timers.Timer(timeout_ms); timer.AutoReset = false; timer.Elapsed += action; }
private static void RecycleVlcControl(VlcControl oldControl, Form hostForm) { oldControl.Stop(); oldControl.ResetMedia(); // hostForm.Controls.Remove(oldControl); // oldControl.Dispose(); var timer = new TimerX { Interval = 1 }; ElapsedEventHandler handler = (s, e) => { hostForm.BeginInvoke(new Action(() => { // CreateVlcControl(hostForm); timer.Enabled = false; oldControl.SetMedia(new FileInfo(source)); oldControl.Play(); })); }; timer.Elapsed += handler; timer.AutoReset = false; timer.Enabled = true; }
void PasteSetup() { if (!Directory.Exists(PasteSync)) return; var dir = new DirectoryInfo(PasteSync); var check = new ElapsedEventHandler(delegate(object s, ElapsedEventArgs e) { foreach (FileInfo file in dir.GetFiles()) { string id = file.Name, nick = File.ReadAllText(file.FullName), info = string.Empty; int z = nick.IndexOf(' '); if (z != -1) { info = string.Concat(" - ", nick.Substring(z + 1)); nick = nick.Substring(0, z); } Message(Channel, string.Format("{0} pasted {1}{2}{3}", new string[] { nick, PasteURI, id, info })); file.Delete(); } }); paste = new Timer(PasteFreq); foreach (FileInfo file in dir.GetFiles()) file.Delete(); paste.Elapsed += check; paste.Start(); }
public TimerBela(double interval, ElapsedEventHandler eventHandler, int gameId) : base(interval) { Elapsed += eventHandler; AutoReset = false; GameId = gameId; OriginalInterval = interval; }
private static void StartTimedDelegate(int interval, ElapsedEventHandler handler) { Timer t = new Timer(interval); t.Elapsed += handler; t.Start(); }
public bool SetTimerPrincipale(DateTime date,TimeSpan intervallo,ElapsedEventHandler start) { TimeSpan data = date - DateTime.Now; _intervalloPrincipale = intervallo; /* #region deregistro foreach (MyInternalTimer timer in _timers.Values) { _timerPrincipale.RemoveEventHandler(timer.Start); } _timerPrincipale.RemoveEventHandler(SetNextIntervalloPrincipale); _timerPrincipale = new MyInternalTimer((long)data.TotalMilliseconds); #endregion #region registro //TODO non devo agganciare al timer principale i secondari ma li faccio partire immediatamente //quando il timer scatta (funzione scatto timer principale) foreach (MyInternalTimer timer in _timers.Values) { _timerPrincipale.AddEventHandler(timer.Start); } #endregion */ _timerPrincipale = new MyInternalTimer((long)data.TotalMilliseconds); _timerPrincipale.AddEventHandler(start); _timerPrincipale.Start(); _timerPrincipale.AddEventHandler(SetNextIntervalloPrincipale); return true; }
//Displays animation on level up. public void levelUp() { timer.Elapsed -= OnTimedEvent; ElapsedEventHandler OnLevelUp = UponMyDeath; lineTimer.Elapsed += OnLevelUp; lineTimer.Enabled = true; while (timerCounter < 8) { if (timerCounter % 2 == 0) { board.drawBoard(ConsoleColor.White); } else { board.drawBoard(); } } lineTimer.Stop(); lineTimer.Elapsed -= OnLevelUp; timerCounter = 0; timer.Elapsed += OnTimedEvent; timer.Interval = ms / level; }
/// <summary> /// Démarre le timer /// </summary> /// <param name="tickMethod">Méthode à appeler lors de chaque tick</param> private void SetTimer(ElapsedEventHandler tickMethod) { _timer = new Timer(15); _timer.Elapsed += tickMethod; _timer.AutoReset = true; _timer.Enabled = true; }
public void Restart(bool autoReset, ElapsedEventHandler cb) { Debug.WriteLineIf(DEBUG, "Reset! " + _sysTime.ElapsedMilliseconds.ToString()); _sysTime.Restart(); if (!_started) { _timer.Stop(); // restart the timer Debug.WriteLineIf(DEBUG, "RE-Starting!"); } else { return; } _cb = cb; _timer.AutoReset = true; _timer.Interval = 200; _timer.Enabled = true; _timer.Start(); _started = true; _interval = (long)_period; _autoReset = autoReset; Debug.WriteLineIf(DEBUG, "Started! " + _sysTime.ElapsedMilliseconds.ToString()); }
static void Callback(object state) { Timer timer = (Timer)state; if (timer.Enabled == false) { return; } ElapsedEventHandler events = timer.Elapsed; if (!timer.autoReset) { timer.Enabled = false; } if (events == null) { return; } ElapsedEventArgs arg = new ElapsedEventArgs(DateTime.Now); if (timer.so != null && timer.so.InvokeRequired) { timer.so.BeginInvoke(events, new object [2] { timer, arg }); } else { try { events(timer, arg); } catch { } } }
void Start() { shipElapsed = new ElapsedEventHandler(OnShipTimedEvent); scoreElapsed = new ElapsedEventHandler(OnScoreTimedEvent); splashElapsed = new ElapsedEventHandler(OnSplashTimedEvent); gameElapsed = new ElapsedEventHandler(OnGameTimedEvent); shipTimer.Elapsed += shipElapsed; scoreTimer.Elapsed += scoreElapsed; splashTimer.Elapsed += splashElapsed; gameTimer.Elapsed += gameElapsed; scoreBoard.text = "Score: " + score.ToString(); StartGame(); shipTimer.Interval = 5000; scoreTimer.Interval = 10000; splashTimer.Interval = 1000; gameTimer.Interval = 1000; gameTimer.Enabled = true; roundTime = 180; splashText = GameObject.Find("SplashText").GetComponent <TextMesh>(); }
private void RemoveShootingHandler(int counter, ElapsedEventHandler playerShootingHandler) { switch (counter) { case 0: QuarterSecondNotifier.QuarterSecondElapsed4 -= playerShootingHandler; return; case 1: QuarterSecondNotifier.QuarterSecondElapsed1 -= playerShootingHandler; return; case 2: QuarterSecondNotifier.QuarterSecondElapsed2 -= playerShootingHandler; return; case 3: QuarterSecondNotifier.QuarterSecondElapsed3 -= playerShootingHandler; return; case 4: QuarterSecondNotifier.QuarterSecondElapsed4 -= playerShootingHandler; return; default: return; } }
public Scheduler(TimeSpan ts, ElapsedEventHandler elapsed) { var timeChecker = new Timer(ts.TotalMilliseconds); timeChecker.Elapsed += elapsed; timeChecker.Enabled = true; }
private void StartTimer(ElapsedEventHandler elapsedEventHandler) { _timer = new(); _timer.Interval = _timerInterval; _timer.Elapsed += elapsedEventHandler; _timer.Start(); }
public IAsyncResult BeginInvoke(Delegate method, object[] args) { ElapsedEventHandler handler = (ElapsedEventHandler)method; InvokeDelegate D = Invoke; return(D.BeginInvoke(handler, args, CallbackMethod, null)); }
internal void TickInternal(double dt) { m_elapsed += dt; if (m_elapsed >= m_interval) { m_elapsed -= m_interval; if (!this.m_autoReset) { Enabled = false; } try { ElapsedEventHandler intervalElapsed = this.onIntervalElapsed; if (intervalElapsed != null) { ElapsedEventArgs elapsedEventArgs = new ElapsedEventArgs(); intervalElapsed(this, elapsedEventArgs); } } catch { } } }
public void DoTimer(double interval, ElapsedEventHandler elapseEvent) { Timer aTimer = new Timer(interval); aTimer.Elapsed += new ElapsedEventHandler(elapseEvent); aTimer.Elapsed += new ElapsedEventHandler((s, e) => ((Timer)s).Stop()); aTimer.Start(); }
void StartTimer(ref Timer t, string intervalKey, ElapsedEventHandler elapsed) { t = new Timer(mIConstants[intervalKey]); t.AutoReset = true; t.Elapsed += elapsed; t.Start(); }
private void Start_time_click(object sender, RoutedEventArgs e) { if (timerActive == false && procList.SelectedProcess != null) { timerActive = true; startTimeBut.Content = "Stop!"; selectedProcess.Content = ""; timedProcLabel.Content = StringHandling.UppercaseFirst(procList.SelectedProcess.ProcessName); int timeSecs = ((int)timeSlider.Value) * 60; ElapsedEventHandler handler = delegate(object anotherSender, ElapsedEventArgs args) { procList.killProcess(procList.SelectedProcess); timerActive = false; Application.Current.Dispatcher.Invoke((Action) delegate() { startTimeBut.Content = "Start!"; timedProcLabel.Content = ""; timerRunningLabel.Content = "H: 0 M: 0 S: 0"; }); }; curTimer = new ExTimer(timeSecs, handler, timerRunningLabel); } else if (timerActive == true && curTimer != null) { curTimer.stop(); curTimer = null; startTimeBut.Content = "Start!"; timerActive = false; timedProcLabel.Content = ""; timerRunningLabel.Content = "H: 0 M: 0 S: 0"; } }
public void init() { sendhandler = new ElapsedEventHandler(sendFunc); overHandler = new ElapsedEventHandler(overPrint); timer20.Elapsed += sendhandler; }
static GameOfLife() { timer = new Timer(1000); cells = new string[NUM_CELLS, NUM_CELLS]; curHandler = null; erase(); }
internal void makeTimer(ElapsedEventHandler handler) { displayRefreshTimer = new Timer(1000 / this.framerate); displayRefreshTimer.Elapsed += handler; displayRefreshTimer.AutoReset = true; displayRefreshTimer.Enabled = true; }
internal static void SetTimer(ElapsedEventHandler onTimedEvent) { timer = new Timer(1200); timer.Elapsed += onTimedEvent; timer.AutoReset = true; timer.Enabled = true; }
public static void Start(ElapsedEventHandler handler, TimeSpan timeSpan) { _timer = new Timer(timeSpan.TotalMilliseconds); _timer.Elapsed += handler; _timer.AutoReset = true; _timer.Enabled = true; }
public TimerTask(int interval, bool repeat, IAsyncResult ar, ElapsedEventHandler handler) { _timer = new Timer(); _timer.Elapsed += handler; _timer.AutoReset = repeat; _timer.Interval = interval; }
/// <summary> /// Creates a /// </summary> /// <param name="callback"></param> /// <param name="time"></param> /// <param name="countdownStart"></param> public Countdown(SteamNerd steamNerd, SteamID chat, ElapsedEventHandler callback, float seconds, int countdownStart) { _countdownTimers = new Timer[countdownStart]; MainTimer = new Timer(seconds * 1000); MainTimer.AutoReset = false; MainTimer.Elapsed += callback; MainTimer.Start(); for (var i = 1; i <= countdownStart; i++) { if (seconds - i <= 0) { return; } var timer = new Timer(seconds - i); var countdownString = string.Format("{0}...", i); timer = new Timer((seconds - i) * 1000); timer.AutoReset = false; timer.Elapsed += (src, e) => steamNerd.SendMessage(countdownString, chat); timer.Start(); _countdownTimers[i - 1] = timer; } }
public void OnBeat(ElapsedEventHandler handler) { lock (this._lock) { this._handler = handler; } }
public static async Task <IEnumerable <FlightDto> > GetFlightsWithDelay(this IFlightService service) { var taskCompletionSource = new TaskCompletionSource <IEnumerable <FlightDto> >(); var timer = new Timer(TimerDelay); timer.Enabled = true; timer.AutoReset = false; try { ElapsedEventHandler timerOnElapsed = async(obj, args) => { taskCompletionSource.SetResult(await service.GetAll()); timer.Enabled = false; }; timer.Elapsed += timerOnElapsed; } catch (Exception ex) { taskCompletionSource.SetException(ex); } return(await taskCompletionSource.Task); }
private void StartTimeoutTracking(int timeoutInSeconds) { ElapsedEventHandler handler = null; if (timeoutInSeconds == 0) { this.SetEndProcessingAction(new Action(this.EndProcessingDoNothing)); } else if (timeoutInSeconds > 0) { lock (this._timerLock) { System.Timers.Timer timer = new System.Timers.Timer { Interval = timeoutInSeconds * 0x3e8, AutoReset = false }; this._timer = timer; if (handler == null) { handler = (_, eventArgs) => this.SetEndProcessingAction(new Action(this.EndProcessingDoNothing)); } this._timer.Elapsed += handler; this._timer.Start(); } } }
public void StartTimer(ref Timer timer, ElapsedEventHandler Event) { timer = new Timer(); timer.Interval = interval; timer.Elapsed += new ElapsedEventHandler(Event); timer.Start(); }
private ElapsedEventHandler CheckerBuilder(Timer timer, ChannelWithEmptyTime channel) { var res = new ElapsedEventHandler((sender, args) => { var vc = client.GetChannel(channel.VoiceChannelId) as SocketVoiceChannel; if (vc == null) { timer.Dispose(); return; } if (vc.Users.Any()) { channel.EmptyTimeSpan = null; return; } else { channel.EmptyTimeSpan = channel.EmptyTimeSpan ?? TimeSpan.Zero; channel.EmptyTimeSpan += TimeSpan.FromMilliseconds(timer.Interval); } if (channel.EmptyTimeSpan > TimeSpan.FromMinutes(1)) { vc.DeleteAsync().GetAwaiter().GetResult(); timer.Dispose(); } }); return(res); }
private void MyTimerCallback(object state) { if (state == this.cookie) { if (!this.autoReset) { this.enabled = false; } FILE_TIME lpSystemTimeAsFileTime = new FILE_TIME(); GetSystemTimeAsFileTime(ref lpSystemTimeAsFileTime); ElapsedEventArgs e = new ElapsedEventArgs(lpSystemTimeAsFileTime.ftTimeLow, lpSystemTimeAsFileTime.ftTimeHigh); try { ElapsedEventHandler onIntervalElapsed = this.onIntervalElapsed; if (onIntervalElapsed != null) { if ((this.SynchronizingObject != null) && this.SynchronizingObject.InvokeRequired) { this.SynchronizingObject.BeginInvoke(onIntervalElapsed, new object[] { this, e }); } else { onIntervalElapsed(this, e); } } } catch { } } }
public void InititateTimer(int interval, ElapsedEventHandler eventHandler) { var timer = new Timer(interval); timer.Elapsed += eventHandler; timer.Start(); }
public Stopwatch(double time, ElapsedEventHandler after) { this.time = time; timer = new Timer(); timer.Elapsed += after; timer.AutoReset = false; }
public BackupUtility(ref IReliableStateManager stateManager, BackupConfig config, ElapsedEventHandler callback) { _stateManager = stateManager; _backupConfig = config; _timer = new Timer(); _timer.Elapsed += callback; _timer.Interval = _backupConfig.BackupInterval; }
public Insomniac() { m_timer=new Timer(); m_handler = new ElapsedEventHandler(handleWakeup); m_timer.Elapsed+=m_handler; m_timer.Interval=timeToAwake; m_timer.Start(); }
private static Timer CreateTimer(ElapsedEventHandler elapsedEventHandler, int timeout, bool continuous, bool startAtCreation) { Timer timer = new Timer((double)(timeout * 0x3e8)); timer.Elapsed += elapsedEventHandler; timer.AutoReset = continuous; timer.Enabled = startAtCreation; return timer; }
public PswsTimer(ElapsedEventHandler elapsedEventHandler, int timeout, bool continuous, bool startAtCreation) { this.timeout = new BoundedInteger(timeout, 1, 0x7fffffff); this.elapsedEventHandler = elapsedEventHandler; this.continuous = continuous; this.timer = PswsTimer.CreateTimer(elapsedEventHandler, this.timeout.Value, this.continuous, startAtCreation); this.disposed = false; }
// ReSharper restore PrivateFieldCanBeConvertedToLocalVariable /// <summary> /// Constructs a new GaugeTimer that invokes the provided handler. /// /// If the interval millis override is provided, it'll be used. Otherwise a /// ConfigurableValue for "mjolnir.gaugeIntervalMillis" || 5000 will be used. /// /// intervalMillisOverride should typically only be used for testing. /// </summary> /// <param name="onTick">Event handler to invoke on tick</param> /// <param name="intervalMillisOverride">Interval override (for unit testing)</param> internal GaugeTimer(ElapsedEventHandler onTick, IConfigurableValue<long> intervalMillisOverride = null) { _gaugeIntervalMillis = intervalMillisOverride ?? new ConfigurableValue<long>("mjolnir.gaugeIntervalMillis", 5000, UpdateStatsGaugeInterval); _timer = new Timer(_gaugeIntervalMillis.Value) { AutoReset = true }; _timer.Elapsed += onTick; _timer.Enabled = true; }
public AsyncTimer(ElapsedEventHandler action, int ticks, int interval) { this.Timer = new Timer(interval); this.Ticks = ticks; this.Timer.Elapsed += action; this.Timer.Elapsed += TickCounter; this.Timer.Enabled = true; }
public void FlashBoxStart() { IsFlashing = true; FlashTimer.Enabled = true; FlashTimer.AutoReset = true; FlashEvent = new ElapsedEventHandler((sender, e) => FlashBoxTick(sender, e)); FlashTimer.Elapsed += FlashEvent; }
public static void Run(Int32 interval, ElapsedEventHandler eventHandler) { Timer timer; timer = new Timer(interval); timer.Elapsed += new ElapsedEventHandler(eventHandler); timer.Enabled = true; timer.AutoReset = true; }
public LicenseTimer(LicenseManagerLauncher licenseManagerLauncher) { Elapsed += new ElapsedEventHandler(licenseTimerElapsed); AutoReset = true; Interval = EXPIRED_REMINDER_FREQUENCY.TotalMilliseconds; lastPeriodicLicenseWarning = DateTime.UtcNow; this.licenseManagerLauncher = licenseManagerLauncher; Start(); }
private static Timer CreateTimer(double interval, ElapsedEventHandler elapsedEventHandler) { WriteDebugOutput($"Creating new timer with interval of {interval}"); var timer = new Timer(interval); timer.Elapsed += elapsedEventHandler; timer.Enabled = true; return timer; }
public bool SetTimer(TimeSpan data,ElapsedEventHandler ev) { if (!_timers.ContainsKey(data)) { MyInternalTimer timerApertura = new MyInternalTimer((long)data.TotalMilliseconds+1); _timers.Add(data, timerApertura); } _timers[data].AddEventHandler(ev); _timers[data].Start(); return true; }
public EmailBox(string Email, string Password, string ImapServer, string SmtpServer, int ImapPort, int SmtpPort, bool SmtpSSL, bool ImapSSL, int interval, ElapsedEventHandler handler) { this.Email = Email; this.Password = Password; this.ImapServer = ImapServer; this.SmtpServer = SmtpServer; this.ImapPort = ImapPort; this.SmtpPort = SmtpPort; this.ImapSSL = ImapSSL; this.SmtpSSL = SmtpSSL; emailTimer = new System.Timers.Timer(interval); this.emailTimer.Elapsed += handler; }
private EasingTimer(int n, TimerFunction func, List<angleXYZ> angles, int dir, rotateAxisType rotateAxis, timerUPFunction funcUp = null) : base(100) { this.firstAngle = 0; this.rotateN = n; this.begin_time = DateTime.Now; this.func = new ElapsedEventHandler(func); this.Elapsed += this.func; this._run = false; this.dir = dir; this.rotateAxis = rotateAxis; this.funcUp = funcUp; }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); WebApiConfig.Register(GlobalConfiguration.Configuration); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteTable.Routes.MapHubs(); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); AuthConfig.RegisterAuth(); GlobalQuarterSecondTimerCounter = 1; quarterSecondTimerHandler = (sender, e) => UpdateCounter(); GlobalQuarterSecondTimer.Enabled = true; GlobalQuarterSecondTimer.Elapsed += quarterSecondTimerHandler; }
public LogicControl(Ballz game) { Game = game; state = GameState.Unknown; ButtonRepeat = new Timer(62.5); ButtonRepeat.AutoReset = true; repeatHandler = (s,e)=>{}; ButtonRepeat.Elapsed += repeatHandler; ButtonDelay = new Timer(1000); ButtonDelay.AutoReset = false; ButtonDelay.Elapsed += (s, e) => { ButtonRepeat.Stop(); ButtonRepeat.Start(); }; }
//TODO: keeping this *only* for testing purposes -- but not sure that even makes sense internal PdhHelper(bool isPreVista, IEnumerable<string> computerNames, IEnumerable<string> counters, bool ignoreBadStatusCodes) { this._isPreVista = isPreVista; this._ignoreBadStatusCodes = ignoreBadStatusCodes; this._backgroundTask = (state, eventArgs) => { _firstRead.Set(); _backgroundTimer.Stop(); _backgroundTimer.Elapsed -= _backgroundTask; }; this._backgroundTimer.Elapsed += this._backgroundTask; ConnectToDataSource(); List<string> validPaths = ParsePaths(counters.PrefixWithComputerNames(computerNames)).ToList(); if (validPaths.Count == 0) throw new Exception(string.Format(CultureInfo.CurrentCulture, GetEventResources.CounterPathIsInvalid, new object[] { string.Empty })); OpenQuery(); AddCounters(validPaths); PerformFirstRead(); }
public static String Add(int delay, ElapsedEventHandler action, bool repeat = false) { String id = Tools.md5(String.Format("{0}", Bot.EpochTimestampMS + (ulong)timers.Count)); Timer t = new Timer(delay); t.Elapsed += action; if (!repeat) t.Elapsed += delegate { t.Stop(); Remove(id); }; lock (timers) { timers.Add(id, t); t.Start(); return id; } }
public void SetTimer(int momentoApertura, int durataApertura, string name, ElapsedEventHandler Apri, ElapsedEventHandler Chiudi) { Timer timerApertura = new Timer(momentoApertura); Timer timerChiusura = new Timer(momentoApertura + durataApertura); timerApertura.Elapsed += Apri; timerChiusura.Elapsed += Chiudi; timerApertura.Start(); timerChiusura.Start(); timerApertura.AutoReset = false; timerChiusura.AutoReset = false; Timer[] timerPerValvola = new Timer[2]; timerPerValvola[0] = timerApertura; timerPerValvola[1] = timerChiusura; _timers.Add(name, timerPerValvola); }
public MyDigitalClock() { InitializeComponent(); deleg = new MethodInvoker(invoke); timer = new ElapsedEventHandler(lblTimeInvoke); Process[] MyProc = Process.GetProcessesByName("time"); if (MyProc.Length == 1 || MyProc.Length == 0) { close = false; } else if (MyProc.Length == 2) { MessageBox.Show("Can't run as the program is already running"); close = true; } ReadFile(); SetOptions(); myTime = new System.Timers.Timer(1000); myTime.Enabled = true; myTime.Elapsed += timer; }
public ExTimer(int seconds, ElapsedEventHandler handler, Label labelToUpdate) { time = seconds; timeElapsed = 0; // Process kill timer. timer.Elapsed += handler; timer.Elapsed += timer_Elapsed; timer.Interval = seconds * 1000; // Seconds to miliseconds. timer.Enabled = true; GC.KeepAlive(timer); this.labelToUpdate = labelToUpdate; if (labelToUpdate != null) { // UI timer. UITimer.Elapsed += updateLabel; UITimer.Interval = 1000; // Each second. UITimer.Enabled = true; // Only enable, if update is wanted. GC.KeepAlive(UITimer); } }
private void InitilizeProgressTimer() { stopWatch.Start(); bool throwing = false; try { progressTimer = new Timer { AutoReset = false, Interval = progressInterval.TotalMilliseconds }; progressTimerOnElapsed = (sender, args) => { ProgressRecord pr; if (progressStatus.TryGetProgressRecord(out pr)) { this.progress(pr); } progressTimer.Enabled = true; }; progressTimer.Elapsed += progressTimerOnElapsed; progressTimer.Enabled = true; } catch (Exception) { throwing = true; throw; } finally { if (throwing && progressTimer != null) { progressTimer.Elapsed -= progressTimerOnElapsed; progressTimer.Enabled = false; progressTimer.Dispose(); progressTimer = null; } } }
public ServiceScheduler() { Services.WundergroundQuery(); try { Timer tmrTimersTimer = new Timer(); int second = 1000; int minute = second*60; tmrTimersTimer.Interval = 10 * minute; // // Anonymous delegate ElapsedEventHandler handler = new ElapsedEventHandler(delegate(object o, ElapsedEventArgs e) { Services.WundergroundQuery(); }); tmrTimersTimer.Elapsed += handler; tmrTimersTimer.Start(); } catch (Exception ex) { } }
/// <summary> /// Creates a /// </summary> /// <param name="callback"></param> /// <param name="time"></param> /// <param name="countdownStart"></param> public Countdown(SteamNerd steamNerd, SteamID chat, ElapsedEventHandler callback, float seconds, int countdownStart) { _countdownTimers = new Timer[countdownStart]; MainTimer = new Timer(seconds * 1000); MainTimer.AutoReset = false; MainTimer.Elapsed += callback; MainTimer.Start(); for (var i = 1; i <= countdownStart; i++) { if (seconds - i <= 0) return; var timer = new Timer(seconds - i); var countdownString = string.Format("{0}...", i); timer = new Timer((seconds - i) * 1000); timer.AutoReset = false; timer.Elapsed += (src, e) => steamNerd.SendMessage(countdownString, chat); timer.Start(); _countdownTimers[i - 1] = timer; } }
/// <summary> /// Constructeur surchargé initalisant un Timer, lui affectant une méthode de réaction et un interval de temps /// </summary> /// <param name="interval">Interval avant que la méthode de réaction ne soit appelée</param> /// <param name="eventManager">Méthode de réaction à appeler lorsque le Timer attaint 0</param> public Minuteur(double interval, ElapsedEventHandler eventManager) : this(eventManager) { this.Timer = interval; }
/// <summary> /// Constructeur par défault /// Instancie un nouveau Timer et lui affecte une méthode de réaction /// </summary> /// <param name="eventManager">Méthode de réaction à appeler lorsque le Timer atteint 0</param> public Minuteur(ElapsedEventHandler eventManager) { timer = new Timer(); timer.Elapsed += eventManager; //affecte la méthode de réaction à l'évènement Elapsed timer.AutoReset = true; //permet de recommencer le compte à rebours une fois fini }