Develop Reference

C# - Winform Timer - Disposing and emptying the timer

Fairly new to C# and timers, although I've managed to do some really fun stuff in C#, however I'm not getting the hang of Timers.
Form1.cs:
private int counter;
static System.Windows.Forms.Timer timer1 = new System.Windows.Forms.Timer();
public void goTimer()
{
// Set Counter
counter = 60;
// If timer is already enabled, stop it.
if (timer1.Enabled)
{
timer1.Dispose();
//timer1.Stop() <- also tried
}
timer1.Tick += new EventHandler(timer1_Tick);
timer1.Interval = 1000; // 1 second
timer1.Start(); // Timer exists
txtCountdown.Text = counter.ToString();
}
private void timer1_Tick(object sender, EventArgs e)
{
counter--;
if(counter == 0)
{
timer1.Stop();
}
txtCountdown.Text = counter.ToString();
}
So, what happens is that it seems to work as intended, until you start calling goTimer(); from e.g. a button press, then it will speed up the (int) counter as many times as you pressed it... And after a while the memory will be eaten up.
In this case the users will be able to do call the timer function, as it will remove some objects, clear some data and refresh the session, but also when the timer reaches 0.
Using Winforms, I did not add a timer in visual studio (it's only referenced here in Form1.cs).
How do I terminate all timers, and then restart at (int) counter?

Using start and stop of the timer would be the proper aproach, but generally also the dispose variant will work.
Your memory hole results from the multiplied event handler assignments, you need to move this method to your constructor or some other initialization method:
timer1.Tick += new EventHandler(timer1_Tick);
If you really want to create a new timer every time, you need to release the event handler before:
timer1.Tick -= timer1_Tick;

First of all, as MichaelSander already mentioned, you should put these lines in your Form1.cs constructor:
timer1.Tick += new EventHandler(timer1_Tick);
timer1.Interval = 1000; // 1 second
Secondly, there is no point in disposing your timer if it's meant to be used more than once. Instead of timer1.Dispose() you should use timer1.Stop() just like you do in your timer1_Tick handler. Also there is no point in checking whether the timer is enabled or disabled as both timer1.Start() and timer1.Stop() will either turn it on/off respectively or do nothing at all. That means that in your case you can remove this block completely:
if (timer1.Enabled)
{
timer1.Dispose();
}

DispatcherTimer keeps increasing memory usage until app crash

I am currently writing an app that mainly makes use of a DispatcherTimer to emulate Stopwatch functionality. While my DispatcherTimer is running within the app, my app's memory usage goes up to 100MB in less than 10 minutes which is especially weird considering how simple the app's functionality is. This wouldn't have normally been a problem except for the fact that the app's rapid increase in memory usage then causes it to crash and close out. I have looked all over the web and repeatedly have come across articles acknowledging the existence of a DispatcherTimer memory leak, however all of the fixes to this memory leak consist of stopping the DispatcherTimer when it is no longer needed. My memory leak occurs while the DispatcherTimer is still needed, not when it is accidentally left running. I need to allow for users to keep their stopwatch running for however long they choose, so stopping the DispatcherTimer when it's not needed anymore doesn't do much for me. I have tried adding GC.Collect() at the end of my TimerTick event handler, however, that didn't seem to do much either.
public MainPage()
{
InitializeComponent();
PhoneApplicationService.Current.ApplicationIdleDetectionMode = IdleDetectionMode.Disabled;
Timer.Stop();
Timer.Interval = new TimeSpan(0, 0, 1);
Timer.Tick += new EventHandler(TimerTick);
Loaded += new System.Windows.RoutedEventHandler(MainPage_Loaded);
}
void TimerTick(object sender, EventArgs e)
{
timeSpan1 = DateTime.Now.Subtract(StartTimer);
timeSpan2 = DateTime.Now.Subtract(StartTimer2);
WatchHour.Text = timeSpan1.Hours.ToString();
WatchMinute.Text = timeSpan1.Minutes.ToString();
WatchSecond.Text = timeSpan1.Seconds.ToString();
SecondaryHour.Text = timeSpan2.Hours.ToString();
SecondaryMinute.Text = timeSpan2.Minutes.ToString();
SecondarySecond.Text = timeSpan2.Seconds.ToString();
if (WatchHour.Text.Length == 1) WatchHour.Text = "0" + WatchHour.Text;
if (WatchMinute.Text.Length == 1) WatchMinute.Text = "0" + WatchMinute.Text;
if (WatchSecond.Text.Length == 1) WatchSecond.Text = "0" + WatchSecond.Text;
if (SecondaryHour.Text.Length == 1) SecondaryHour.Text = "0" + SecondaryHour.Text;
if (SecondaryMinute.Text.Length == 1) SecondaryMinute.Text = "0" + SecondaryMinute.Text;
if (SecondarySecond.Text.Length == 1) SecondarySecond.Text = "0" + SecondarySecond.Text;
}
This is my TimerTick event handler and a bit of my MainPage constructor, the textboxes present in the event handler display the time elapsed from starting the stopwatch. Am I doing something specifically wrong here that is causing such a huge increase in memory? I had previously thought the issue was because the TextBoxes were somehow caching their previous contents by default coupled with rapid changes in text due to the stopwatch functionality, however, after completely removing the TextBoxes from my app and analyzing it, I am quite sure they aren't the problem. As stated above, adding GC.Collect() at the end of this TimerTick handler didn't do anything to decrease my memory usage. Does anyone have an idea of how I could reduce my memory usage with DispatcherTimer, maybe by somehow manipulating the GC function to actually work?
Thanks in advance!

Why are you declaring the timespan1 and timespan2 outside of the timer tick event? Does the memory look better if you create it inside of the event handler

Could you please try the following code snippet,
Step:1
Add the button and textblock in xaml first.
Step:2
Use the following namespaces:
using System.Diagnostics; // for Stopwatch API Access
Step:3 use the below mentioned code snippet:
public partial class WmDevStopWatch : PhoneApplicationPage
{
Stopwatch stopWatch = new Stopwatch();
DispatcherTimer oTimer = new DispatcherTimer();
public WmDevStopWatch()
{
InitializeComponent();
oTimer.Interval = new TimeSpan(0, 0, 0, 0, 1);
oTimer.Tick += new EventHandler(TimerTick);
}
void TimerTick(object sender, EventArgs e)
{
Dispatcher.BeginInvoke(() =>
{
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
stopWatch.Elapsed.Hours, stopWatch.Elapsed.Minutes, stopWatch.Elapsed.Seconds,
stopWatch.Elapsed.Milliseconds / 10);
textBlock1.Text = elapsedTime;
});
}
private void button1_Click(object sender, RoutedEventArgs e)
{
stopWatch.Start();
oTimer.Start();
}
}
Hope it works for you.
Let me know your feedback for the same.

I have finally isolated the core of my memory leak, the issue was not with my DispatcherTimer but instead with my AdRotator Control. The problem has been identified on the side of the AdRotator developers and I am currently using a different Ad control until the problem is fixed.
Thank you all for your help, I really appreciate your time and effort!

Changing Time On MaskedTextbox

I want to design changing time on maskedtextbox in my application like windows where time changes on every second. I have set maskedtexbox1 as below:
maskedTextBox1.Text = DateTime.Now.ToShortTimeString();
which is showing current system short time but it’s not changing on every second like windows. How to do?
I'm on Visual Studio 2005, and .NET is below 3.5.

I'd use the timer and fire an event every second to update the time.
Create a timer (an instance of class Timer in the package System.Windows.Forms).
Set its frequency to 1 second (i.e. 1000 milliseconds).
Tell it what method to call when it goes off (the event handler Kaboom).
Somewhere in your executable code you do that by typing the following.
Timer ticker= new Timer();
ticker.Interval = 1000;
ticker.Tick += new EventHandler(Kaboom);
In the same class (or, if you're confident how to do it, somewhere where you can reach the code) you also create the handler for the fired event of ticking, so that the promise you made about a method to be called when the timer goes off is kept.
private void Kaboom(Object sender, EventArgs eventArgs)
{
// Execute the tickability code
MaskedTextBox1.Text = DateTime.Now.ToShortTimeString();
}
Also, don't forget to actually start your ticker when you feel that you're ready.
MyTimer.Start();
Tada!
EDIT:
For the sake of completeness, I'm also going to paste in a part of the reply of #CuaonLe (a higher threshold of competence and requirement for .NET 3.5 or newer).
Timer timer = new Timer { Interval = 1000 };
timer.Tick += (obj, args)
=> MaskedTextBox1.Text = DateTime.Now.ToLongTimeString();
timer.Start();

I guess you'll need to setup a Timer which updates your maskedTextBox1 every second.
For how to do that, please see: Add timer to a Windows Forms application
Cheers. Keith.

You can use System.Windows.Forms.Timer to update textbox value every second for example:
var timer = new Timer();
timer.Interval = 1000;
timer.Tick += delegate
{
textBox1.Text = DateTime.Now.ToLongTimeString();
};
timer.Start();

Is this a memory leak or will garbage collection fix it

Lets say I have a button that gets clicked and it does this:
public void ButtonClick(object sender, EventArgs e)
{
System.Timers.Timer NewTimer = new System.Timers.Timer();
NewTimer.AutoReset = false;
NewTimer.Elapsed += new ElapsedEventHandler(TimerElapsed);
NewTimer.Interval = 1000;
NewTimer.Start();
}
public void TimerElapsed(object sender, ElapsedEventArgs e)
{
}
If this button gets clicked 100 times what happens to those instances that have been created? Will garbage collection kick in or does the System.Timers.Timer.Close method need calling and if it does where do you call it from?

No this will not cause a memory leak. In fact the way your code is written it's not guaranteed to execute properly. Timers.Timer is really just a wrapper over Threading.Timer and it's explicitly listed as being collectable even if it's currently running.
http://msdn.microsoft.com/en-us/library/system.threading.timer.aspx
Here you keep no reference to it and hence the very next GC could collect it while your form is still running and before the event ever fires
EDIT
The documentation for Timers.Timer appears to be incorrect. The Timer instance will not be collected if it's unreferenced. It will indeed live on
var timer = new System.Timers.Timer
{
Interval = 400,
AutoReset = true
};
timer.Elapsed += (_, __) => Console.WriteLine("Stayin alive (2)...");
timer.Enabled = true;
WeakReference weakTimer = new WeakReference(timer);
timer = null;
for (int i = 0; i < 100; i++)
{
GC.Collect();
GC.WaitForPendingFinalizers();
}
Console.WriteLine("Weak Reference: {0}", weakTimer.Target);
Console.ReadKey();

They will be collected once method is left. TimerElapsed will be either called or not depending on when Timer gets finalized. Most likely it will be dead long before 1 second passed.
When you call Timer.Close() you thus call Timer.Dispose() that de-registers timer from timer queue and in that case TimerElapsed won't be called (of course if it was not called before).
If you leave timer not closed, GC will eventaully call Finalize() that in turn will call Dispose(). But there is not exact knowledge when it will happen :)
See below example, Console.Out.WriteLine("called!!!") will never execute:
using (System.Timers.Timer NewTimer = new System.Timers.Timer())
{
NewTimer.AutoReset = false;
ElapsedEventHandler TimerElapsed = (sender, args) => { Console.Out.WriteLine("called!!!"); };
NewTimer.Elapsed += new ElapsedEventHandler(TimerElapsed);
NewTimer.Interval = 1000;
NewTimer.Start();
}
Thread.Sleep(3000);

After answers by the_joric and JaredPar and running profiler tests which showed timers sticking around after garbage collection kicked in the reason they stuck around was because there is a reference to the event handler sticking around. For a more detailed explanation see this answer.
The real answer is that it is a memory leak unless the timer is closed in the elapsed event handler.
Just goes to show that although I trust the answers on SO (maybe too much) from the great contributors they may be slightly off.

Stopping DispatcherTimer in its own anonymous Tick event handler

Is it safe to do something like this:
private void MyFunction()
{
DispatcherTimer timer = new DispatcherTimer();
timer.Interval = new TimeSpan(0, 0, 1);
timer.Tick += (object sender, object e) =>
{
timer.Stop();
// Some code here
};
timer.Start();
}

Matt raise the point that the way you attach the anonymous method that there is no easy way to detach it. Here is a general pattern you can use to enable you to detach if necessary.
private void MyFunction()
{
DispatcherTimer timer = new DispatcherTimer();
timer.Interval = new TimeSpan(0, 0, 1);
EventHandler eh = null;
eh = (object sender, object e) =>
{
timer.Tick -= eh;
timer.Stop();
// Some code here
};
timer.Tick += eh;
timer.Start();
}
However in this specific case there is nothing wrong with the way your original code works since the timer becomes collectable as soon as it is stopped.

Yes. Your timer will fire once.

Edit: I'll rephrase my answer based on the comments. In the situation you've given, yes it's perfectly safe to use an anonymous delegate.
There are some situations in which adding an anonymous delegate and not detaching it could prevent your class from being garbage collected (for example, attaching an anonymous delegate to a singleton). See this answer for information about when it is and isn't necessary to detach the event handler.