Develop Reference

Why doesn't the Timer Start in Program?

I have a simple C# program (done in MS visual Studio 2010).
It is a windows form with a single button on it. As you can see its just a simple program but Im stuck on it.
I am trying to understand C# timers and global variables in C#.
I wanted it to do the following, when the button is pressed
a message box appears (every second) displaying the number
of seconds since the button was pressed.
It supposed to working by setting a variable starttimer to true (in one function) and in another function when that starttimer equals true is detected it shows the time in seconds in the message box.
However it it doesn't seem to detect that starttimer equals true in the other function. The purpose of the starttimer variable is to detect the button press for using to start showing the message box every second.
So what the easiest way to fix this program?
PS When the program is run without the code for starttimer it does show the message box every second (when the program is started).
A picture of the program windows form is shown -as you can see it really simple-just one button.
namespace timerprogram
{
public partial class doeverysecond : Form
{
int thetimeinsecs = 0;
bool starttimer = false;
private void Form1_Load(object sender, EventArgs e)
{
}
private void customfn(object source, ElapsedEventArgs e)
{
if (starttimer == true)
{
thetimeinsecs = thetimeinsecs + 1;
MessageBox.Show(thetimeinsecs.ToString());
}
}
public doeverysecond()
{
{
{
System.Timers.Timer mytimer = new System.Timers.Timer();
mytimer.Elapsed += new ElapsedEventHandler(customfn);
mytimer.Interval = 1000;
mytimer.Start();
}
}
}
private void button1_Click(object sender, EventArgs e)
{
starttimer = true;
}
}
}

So what the easiest way to fix this program?
Actually it would be to hit the button, so that the variable starttimer is set to true and you will be able to see the MessageBoxevery second. You program works!
Beside that it would be good to bring more structure into your program, by having a method that starts the timer with a button click:
private void button1_Click(object sender, EventArgs e)
{
if(!mytimer.Enabled) // this will prevent a double start
{
starttimer = true;
mytimer.Start();
}
}
The constructor should get rid of the timer start line:
public doeverysecond()
{
{
System.Timers.Timer mytimer = new System.Timers.Timer();
mytimer.Elapsed += new ElapsedEventHandler(customfn);
mytimer.Interval = 1000;
}
}
Division of responsibilities is important here. The constructor is for initialisation of variables. So this is his job. The Button starts the timer.
The if-clause to check if (starttimer == true) is actually not necessary, since you never call this method from somewhere else in your code.
And setting the boolean variable to true does not start the timer. It is only a flag!

Timers can be a bit weird, but it looks like your main issue is that mytimer is within a method scope, meaning that when that method ends, mytimer is cleaned up by the garbage collector and it stops running. This happens because when the method ends, there is no way to access mytimer again from elsewhere in the code. To save on memory, .NET cleans up after you, but in this particular case it's not smart enough to know that you are actually still using the timer.
The solution is quite simple, put mytimer at the class level. You can also get rid of the starttimer bool, as now you can check the timer itself to see if it's running.
You could do something like:
namespace timerprogram
{
public partial class doeverysecond : Form
{
//Timer is class level, so it sticks around and can be called from
//multiple methods
System.Timers.Timer mytimer = new System.Timers.Timer();
int thetimeinsecs = 0;
private void Form1_Load(object sender, EventArgs e)
{
//Setup the timer, but don't start it
mytimer.Elapsed += new ElapsedEventHandler(customfn);
mytimer.Interval = 1000;
}
private void customfn(object source, ElapsedEventArgs e)
{
//We can check the timer itself to see if it's running!
if (mytimer.Enabled)
{
thetimeinsecs = thetimeinsecs + 1;
MessageBox.Show(thetimeinsecs.ToString());
}
}
private void button1_Click(object sender, EventArgs e)
{
//Start the timer!
mytimer.Start();
}
}
}
Oh, and with regards to that whole 'scope' thing. In C#, a scope is basically something in between a { and a }. In methods and normal code, variables created inside a scope cannot be seen by code outside the scope. That's why you get a compiler error if you do something like:
if(something)
{
int x = 5;
}
x = x + 5; //x doesn't exist here! It disappears at }
You can access things from outside a scope inside a scope though, so
int x = 0;
if(something)
{
x = 5; //x exists in an outside scope
}
x = x + 5; //This is fine
Anything at the class scope can be seen by all methods inside a class, which is why the timer now sticks around. Class scope is slighty different though, in that you can see things in other classes if they have public before them. The same goes for methods (Note that all your methods have 'private', so outside classes can't call them. Change them to public and they can!)

Need to enable the timer.
myTimer.Enabled = true

Reduce an integer every second in c# [closed]

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 6 years ago.
Improve this question
I'm trying to figure out how to reduce an integer every second. Everything suggests things that are many, many lines long, and are explaining things in a generic, interchangeable way. So far I've set it up as...
public int timer = 180;
public Text timerCounterText;
// Use this for initialization
void Start ()
{
timerCounterText.text = "Time Left: " + timer.ToString();
}
Now I have no idea how to actually make the integer decrease by one each second, I don't want any suggestions of a potentially better way to do it unless there's no way to do it from what I have here.
I just want a simple, in as few lines as possible way to reduce my timer integer by 1 each second, as the way I have done this is the only way I understand how to do this so far.
Sorry if this is too much to ask, I just want a script I can understand, not just one that works best, as I'm just a student, not making a product.

I have worked a lot with timers in C# (a HELL of a lot - I used to develop software for a Sports Timing company).
There are a few ways of doing it. Some more accurate than others.
The simplest - which is the way you're looking at would be like so:
Set your total seconds in a private field:
private int _secondsRemaining = 180; // 3 minutes
Create a Timer stored in a private field:
private System.Timers.Timer _countdownTimer;
Create a StartTimer() method. Initialize the _countdownTimer, and create an Event Handler for when the timer ticks - this is what happens when it "reaches 0"/fires/whatever you want to call it:
public void StartTimer()
{
_countdownTimer = new System.Timers.Timer(1000); // 1000 is the number of milliseconds
// 1000ms = 1 second
// Set a handler for when the timer "ticks"
// The "Tick" event will be fired after 1 second (as we've set it)
// The timer will loop, though and keep firing until we stop it
// Or unless it is set to not automatically restart
_countdownTimer.Tick += OnTimer_Tick;
// Start the timer!
_countdownTimer.Start();
}
You will need to call StartTimer() from somewhere in your program, otherwise it won't ever start (obviously) - you can do this from the constructor or a button click etc.
Now, create an Event Handler for when the timer ticks. In this, decrement (take 1 from) the _secondsRemaining value; and then display it in your timerCounterText label:
// This is what gets fired when the timer "reaches 0"
private void OnTimer_Tick(object sender, ElapsedEventArgs e)
{
_secondsRemaining--; // the same as "_secondsRemaining = secondsRemaining -1"
timerCounterText.Text = string.Format("Time Remaining: {0} seconds",
_secondsRemaining);
}
This is a nice and easy way to make a countdown timer.
The drawback is, that the timer doesn't fire EXACTLY every second, so you may notice a little bit of drift.
Like I mentioned; depending on the accuracy you need, there are other ways I have used. It depends on what the timer's being used for.
WAIT! There's more!
What would also be useful (if you need it), is, when the _secondsRemaining reaches 0 to stop the timer.
Create a StopTimer() method:
private void StopTimer()
{
if (_countdownTimer != null)
{
_countdownTimer.Tick -= OnTimer_Tick;
_countdownTimer.Stop();
_countdownTimer.Dispose();
_countdownTimer = null;
}
}
You could also use this method when you want to stop the timer manually from a button click or whatever.
Notice the null check, and the code within it. The null check is just for damage limitation in case the _countdownTimer hasn't been initialized etc. and to stop your program bombing out if so.
The code within the if check unsubscribes from the Tick event, stops the timer (obviously), and then gets rid of the _countdownTimer - you don't need to; but you will need to unsubscribe & stop it...
If we called StartTimer() again and initialized the timer, we'd be adding another subscription to the Tick event - this would cause the OnTimer_Tick method to be called twice every time the _countdownTimer fires (and so on and so forth).
Now, in your OnTimer_Tick handler, where we decrement the value of _secondsRemaining - check after, if it is less or equal to 0:
private void OnTimer_Tick(object sender, ElapsedEventArgs e)
{
_secondsRemaining--; // decrement the _secondsRemaining as before
if (_secondsRemaining <= 0)
{
StopTimer(); // This will stop the timer when the _secondsRemaining
// reach 0 (or go below - it shouldn't)
// You can also add in other stuff to happen at 0
// such as "Ending the game", as you described
}
// Display the time remaining, still - as before
timerCounterText.Text = string.Format("Time Remaining: {0} seconds",
_secondsRemaining);
}
Where the check for _secondsRemaining <= 0 is, you could also add your own methods for other things to happen - such as Ending your game as you asked in your question :)
I won't go into any more detail; and I'll let you figure it out - but you could even add in ResetTimer() methods, so you could start the timer again.
I hope this helps - any questions or any other ways to do timers you need; just ask.

I would advise a separate thread doing a decrease in the integer. I would do this with a while loop
public event SecondHappenedEventHandler SecondHappened;
public delegate void SecondHappenedEventHandler(int second);
private int timer = 180;
Public Void Start()
{
timer = 180;
Thread th = New Thread(New ThreadStart(Monitor);
th.Start();
}
Private Void Monitor()
{
While (timer != 0)
{
timer--;
SecondHappened(timer);
Thread.Sleep(1000); //This is milliseconds
}
}
My C# is a little rusty since I have been doing VB more recently for work. Then Add a raiseevent in that class that passes back the integer to the the other class. So your other class would make an instance of this class and have an event that gets the second passed back and display it to the end user.
public Text timerCounterText;
private TimerClass timer;
// Use this for initialization
void Start ()
{
timer.Start
}
private void SecondHappened(int timerBack)
{
timerCounterText.text = "Time Left: " + timerBack.ToString();
}

You can use one of the few Timer classes in .NET in order to get your program do stuff in regular intervals. There's usually one type of timer class that is appropriate for a given situation depending on your app type(i.e. Windows, Console, Service...etc)
Since you are after a simple example, you can have a look at the System.Timers.Timer class:
Generates an event after a set interval, with an option to generate recurring events.
Example of it's usage in a console application (P.S. If you have Windows Forms apps, you probably don't want to use it in this way):
int _countDown = 180;
void Start()
{
var timer = new System.Timers.Timer(1000); // Duration in milliseconds
timer.Elapsed += async ( sender, e ) => await HandleTimer();
timer.Start();
}
void HandleTimer()
{
_countDown--;
Console.WriteLine("Time Left: {0}", _countDown);
}

If you work in WF (Windows Forms), I suggest using a Timer. Create a timer control, set it's interval to 1000 (milliseconds), and in your start function just enable it:
void Start ()
{
timer1.Enabled = true;
timerCounterText.text = "Time Left: " + timer.ToString();
}
Now, a double click on the timer should create a timer_tick event. Use it like that:
void timer_Tick(object sender, EventArgs e)
{
timerCounterText.text = "Time Left: " + (--timer).ToString();
}
Then it should reduce the timer by 1 every second. Of course you should check when it arrives to 0, and then set timer1.Enabled to false.

Using the Decrement Operator --
If you wanted to decrement it prior to the value being updated, you could use the decrement operator --:
void Start ()
{
// This will decrement the timer by 1
timer--;
// Output the value
timerCounterText.Text = "Time Left: " + timer.ToString();
}
You could also accomplish this same thing inline using prefix notation, which will update the value prior to using it :
void Start ()
{
// Decrement your count and output it
timerCounterText.Text = "Time Left: " + (--timer).ToString();
}
Cleaning Up Your Output
You can clean up your output a bit more by using the String.Format() method as well :
void Start ()
{
// Decrement your count and output it
timerCounterText.Text = String.Format("Time Left: {0}",--timer);
}
or if you are using C#, you can take advantage of String Interpolation :
void Start ()
{
// Decrement your count and output it
timerCounterText.Text = $"Time Left: {--timer}";
}
Making Your Timer Tick
Assuming that you are using a Timer class, you can set it's Tick event to be triggered as a certain interval. This is what you would use to actually decrement your value and output it to the user :
// Define a timer
Timer countDown = new Timer();
// Sets the timer interval to 1 seconds.
countDown.Interval = 1000;
// Call the tick event every second
countDown.Tick += new EventHandler(Tick);
// Start your timer
countDown.Start();
and your Tick event would look like this :
private static void Tick(Object myObject,EventArgs myEventArgs)
{
// Check if your timer has run out
if(countDown <= 0)
{
// Timer has run out, handle accordingly
countDown.Stop();
}
else
{
// Otherwise output and decrement
String.Format("Time Left: {0}",--timer);
}
}

C# How to pause a timer?

I have a C# program in which, I need the timer to stop if the user stops interacting with the program. What It needs to do is pause, and then restart when the user becomes active again. I have done some research, and found that there is commands such as:
timer.Stop();
and
timer.Start();
But I was wondering if there was like a:
timer.Pause();
And then when the user becomes active again, it picks up where it left off, and doesn't restart. If anyone can help, it would be much appreciated!
Thanks,
Micah

You achieve this by using the Stopwatch class in .NET. By simply stopping and starting you continue the use of the instance of the stopwatch.
Make sure to make use of using System.Diagnostics;
var timer = new Stopwatch();
timer.Start();
timer.Stop();
Console.WriteLine(timer.Elapsed);
timer.Start(); //Continues the timer from the previously stopped time
timer.Stop();
Console.WriteLine(timer.Elapsed);
To reset the stopwatch, just call the Reset or Restart methods, like below:
timer.Reset();
timer.Restart();

I have created this class for this situation:
public class PausableTimer : Timer
{
public double RemainingAfterPause { get; private set; }
private readonly Stopwatch _stopwatch;
private readonly double _initialInterval;
private bool _resumed;
public PausableTimer(double interval) : base(interval)
{
_initialInterval = interval;
Elapsed += OnElapsed;
_stopwatch = new Stopwatch();
}
public new void Start()
{
ResetStopwatch();
base.Start();
}
private void OnElapsed(object sender, ElapsedEventArgs elapsedEventArgs)
{
if (_resumed)
{
_resumed = false;
Stop();
Interval = _initialInterval;
Start();
}
ResetStopwatch();
}
private void ResetStopwatch()
{
_stopwatch.Reset();
_stopwatch.Start();
}
public void Pause()
{
Stop();
_stopwatch.Stop();
RemainingAfterPause = Interval - _stopwatch.Elapsed.TotalMilliseconds;
}
public void Resume()
{
_resumed = true;
Interval = RemainingAfterPause;
RemainingAfterPause = 0;
Start();
}
}

There is not a pause because it is easy to do the equivalent. You can just stop the timer instead of pausing it, then when you need to restart it you just need to specify the amount of time remaining. It might be complicated or it might be simple; it depends on what you are using the timer to do. The fact that what you do depends on what you are using the timer for is probably the reason a pause does not exist.
You might be using the timer to do something repetitively at a regular time period or you might be using the timer to count down to a specific time. If you are doing something (such as every second) repetitively then your requirements might be to restart at the beginning of that time period (a second) or at a portion of that period. What happens if the pause is for more than the time period? Usually the missed events would be ignored but that depends on requirements.
So I am trying to say that you need to determine your requirements. Then if you need help then clarify what you need.

Using timers which continue only if the callback has been executed till the end

I'm developing a game server and I need to handle some events. By exemple : a player want to attack another player. If he can, an event is executed every seconds which deals damage.
There's a sample code which is not working, but I hope you will get the idea !
using System.Timers;
public class Test
{
public static Timer FightTimer;
// Session is the player
public static void Main(Session Session)
{
FightTimer = new Timer(1000); // one second interval
// Hook up the Elapsed event for the timer.
FightTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
// Set the Interval to 1 seconds (2000 milliseconds).
FightTimer.Interval = 1000;
FightTimer.Enabled = true;
}
public static void Fight(object attacker)
{
FightTimer.stop();
// get the session
Session Session = (Session)attacker;
if (Session.CharacterInfo.IsDestroy == true)
{
return;
}
// Ok here will be calculated all damage and ect...
// if there's no others "return" for stopping the execution we can let the timer call
// the callback again. if not, the timer is stopped and disposed
FightTimer.start();
}
}
Well I hope you got the idea, my problem is I don't know at all how I can do that so I hope you will be able to help me. Thanks in advance !

Since you are using the System.Timer class you can use the System.Timer.Enabled property. Setting the property to false will stop the timer ticking - it will not raise the Elapsed event anymore.
What need to be changed in your code:
make the timer variable global (or pass it to the desired method)
then use FightTimer.Enabled = false; to stop it
The modified code (one possible solution):
using System.Timers;
public class Test
{
// Session is the player
static Timer FightTimer = null;
public static void Main(Session Session)
{
FightTimer = new Timer(1000); // one second interval
// Hook up the Elapsed event for the timer.
FightTimer.Elapsed += new ElapsedEventHandler(Fight);
// Set the Interval to 1 seconds
FightTimer.Interval = 1000;
FightTimer.Enabled = true;
}
public static void Fight(object attacker)
{
// get the session
Session Session = (Session)attacker;
if (Session.CharacterInfo.IsDestroy == true)
{
return;
}
// Ok here will be calculated all damage and ect...
// if there's no others "return" for stopping the execution we can let the timer call
// the callback again. if not, the timer is stopped and disposed
FightTimer.Enabled = false;
// modify to your needs
}
}

Getting notified when the datetime changes in c#

Recently I was trying to make a calendar application that will display the current year-month-date to the user. The problem is, if the user is gonna keep my application running even for the next day, how do I get notified ?? How shall I change the date displayed ? I don't wanna poll the current date to update it. Is this possible in c#.
Note: I tried out the SystemEvent.TimeChanged event, but it works only if the user manually changes the time / date from the control panel.

#OddThinking's answer will work (you could set a timer for the interval instead of sleeping). Another way would be to set a timer with a 1 minute interval and simply check if the system date has changed. Since you are only executing some lightweight code once a minute, I doubt the overhead would be noticable.

public void Main()
{
var T = new System.Timers.Timer();
T.Elapsed += CallBackFunction;
var D = (DateTime.Today.AddDays(1).Date - DateTime.Now);
T.Interval = D.TotalMilliseconds;
T.Start();
}
private void CallBackFunction(object sender, System.Timers.ElapsedEventArgs e)
{
(sender as System.Timers.Timer).Interval = (DateTime.Today.AddDays(1).Date - DateTime.Now).TotalMilliseconds;
}

Can you simply work out the number of seconds until midnight, and then sleep for that long?

Try looking into monitoring WMI events, you should be able to create a Wql event query that monitors the day of week change (i.e. ManagementEventWatcher etc) and then setup an event handler that fires when the event arrives.
using System;
using System.Management;
class Program
{
public static void Main()
{
WqlEventQuery q = new WqlEventQuery();
q.EventClassName = "__InstanceModificationEvent ";
q.Condition = #"TargetInstance ISA 'Win32_LocalTime' AND TargetInstance.Hour = 22 AND TargetInstance.Minute = 7 AND TargetInstance.Second = 59";
Console.WriteLine(q.QueryString);
using (ManagementEventWatcher w = new ManagementEventWatcher(q))
{
w.EventArrived += new EventArrivedEventHandler(TimeEventArrived);
w.Start();
Console.ReadLine(); // Block this thread for test purposes only....
w.Stop();
}
}
static void TimeEventArrived(object sender, EventArrivedEventArgs e)
{
Console.WriteLine("This is your wake-up call");
Console.WriteLine("{0}", new
DateTime((long)(ulong)e.NewEvent.Properties["TIME_CREATED"].Value));
}
}

How about a thread that checks for change in date. The thread can have some events that the controls that need this information can subscribe to.