How to fire timer.Elapsed event immediately

I'm using the System.Timers.Timer class to create a timer with an Timer.Elapsed event. The thing is the Timer.Elapsed event is fired for the first time only after the interval time has passed.

Is there a way to raise the Timer.Elapsed event right after starting the timer ?

I couldn't find any relevant pro开发者_开发问答perty in the System.Timers.Timer class.

Just call the Timer_Tick method yourself.

If you don't want to deal with the Tick callback method's parameters, then just put the code that was in your Timer_Tick into another method, and call that from the Timer_Tick and from just after the Timer.Start() call

As pointed out by @Yahia, you could also use the System.Threading.Timer timer, which you can set to have an initial delay to 0. Be aware though, that the callback will run on a different thread, as opposed to the callback on the Windows.Forms.Timer which runs on the UI thread. So if you update any UI controls using the System.Threading.Timer (without invoking correctly) it'll crash.

I just called the **ElapsedEventHandler** with null parameters.

I know this answer is late but if you want your System.Timers.Timer to be fired within 100ms (default interval) then you could simply just initialize the Timer object without a specified interval, then set the interval within the called function to whatever you like. Here is an example of what I use in my Windows Service:

private static Timer _timer;

protected override void OnStart(string[] args)
{
    _timer = new Timer(); //This will set the default interval
    _timer.AutoReset = false;
    _timer.Elapsed = OnTimer;
    _timer.Start();
}

private void OnTimer(object sender, ElapsedEventArgs args)
{
    //Do some work here
    _timer.Stop();
    _timer.Interval = 50000; //Set your new interval here
    _timer.Start();
}

Try System.Timers.Timer

System.Threading.Timer t = new System.Threading.Timer(new TimerCallback(DoSomething), null, 0, 30000);

This starts immediately (0 milliseconds for the first run, 30000 milliseconds for subsequent runs)

see
System.Timers.Timer docs

System.Timers.Timer constructor

Task.Run(() =>
{
   Timer_Elapsed(null, null);
});

After Timer creation/configuration, worked fine for me...

For the first time, the timer will start after 1 second. After that, its interval will be changed to every 30 seconds or whatever...

    //main function    
    Timer timer = new Timer(1000);   //initial start after 1 second
        timer.Elapsed += new ElapsedEventHandler(TimerElapsedMethod);
        timer.Start();            
    }
    private void TimerElapsedMethod(object sender, ElapsedEventArgs e) 
    {
        Timer timer = (Timer)sender; // Get the timer that fired the event
        timer.Interval = 30000;      // Change the interval to whatever
        .
        .
        .
    }

If you want to be able to raise the event whenever you want (not only just at the moment you start the timer), you can encapsulate a timer in your own MyTimer class. This class exposes the original Timer methods and properties. Furthermore I added an event with explicit add and remove. In this way whenever you add a delegate to the event this is added to both the private MyTimer's event and to the original timer Elapsed event. This means that the timer triggers Elapsed in the usual way, but you can manually trigger the event calling RaiseElapsed (this should sound much simpler looking at the code).

public class MyTimer
{
    Timer t = new Timer();
    event ElapsedEventHandler timerElapsed;

    public event ElapsedEventHandler Elapsed
    {
        add
        {
            t.Elapsed += value;
            timerElapsed += value;
        }
        remove
        {
            t.Elapsed -= value;
            timerElapsed -= value;
        }
    }

    public double Interval
    {
        get
        {
            return t.Interval;
        }
        set
        {
            t.Interval = value;
        }
    }

    public void Start()
    {
        t.Start();
    }

    public void Stop()
    {
        t.Stop();
    }

    public void RaiseElapsed()
    {
        if (timerElapsed != null)
            timerElapsed(null, null);
    }
}

I have implemented in VB.NET with AddHandler

Public Class clsMain Inherits ServiceBase

Protected Overrides Sub OnStart(ByVal args() As String)
' Add code here to start your service. This method should set things
' in motion so your service can do its work.
gTimer.Interval = 1000  
gTimer.Enabled = True
AddHandler gTimer.Elapsed, AddressOf gTimer_Elapsed
End Sub

'When the timer is elapsed this event will be fired

Protected Sub gtimer_Elapsed(ByVal source As Object, ByVal e As ElapsedEventArgs)
'Stop the timer and do some work
gTimer.Stop()
'Custom code
'Here
'Start to raise the elapsed event again
gTimer.Start()
End Sub
End Class

I'm not a pro so take this with a pinch of salt but it works. I created a function and instead of putting my code into the timer sub I put it into the function. Then I merely called the function when I wanted it (in my case on page load) and then the timer code would fire at the interval times and simply call the function in the timer sub code.

Here is the easy answer. (Assuming you're using a Windows form)

After dragging your timer control to your form, set the enabled property to true, and the Interval property to whatever you want the initial value to be. (100 is the default and will start the tick event immediately)

Then within your tick event, simply check the value of the Interval property. If it is not your desired value, set it. It's that simple. The same can be accomplished in your C# code if creating a timer on the fly.