Building Windows Service in C# with periodic task

Question

Id like to build a windows Service in C#.

This service needs to be run periodically like every 10s.

Questions:

1. What is the difference between Timers.timer and Threading.timer?

2. How can I call CheckingThings with parameters?

3. If i run this code, it does invoke CheckingThings more than once every second like declared in here:

_timer = new Timer(new TimerCallback(CheckingThings), autoEvent, 5000, 1000);

Here is what i've got so far:

public partial class WindowsService1 : ServiceBase
{

    // Logging
    private static Serilog.Core.Logger _logEvent;


    public WindowsService1()
    {
        InitializeComponent();
    }

    public void OnDebug() {
        OnStart(null);
    }


    protected override void OnStart(string[] args)
    {

        //Logging
        try {
            _logEvent = new LoggerConfiguration()
                .WriteTo.File(AppDomain.CurrentDomain.BaseDirectory + @"Logs\Logfile.txt", rollingInterval: RollingInterval.Month)
                .CreateLogger();
        }
        catch (Exception e)
        {
            _logEvent.Error("The logging service is not working as expected: {errorMsg}", e);
        }

        try
        {
        // initializing some data here

                var autoEvent = new AutoResetEvent(true);
                while (true)
                {
                    _timer = new Timer(new TimerCallback(CheckingThings), autoEvent, 5000, 1000);
                }
        }
        catch (Exception e) {
            _logEvent.Error("An error occured while initializing service: {0}", e);
        }
    }

    private static void CheckingThings(object stateInfo) 
        AutoResetEvent autoEvent = (AutoResetEvent)stateInfo;

    //These things needs to run periodically every 10s
    }

    protected override void OnStop()
    {
        _logEvent.Information("Stopping  Service ...");
    }

}

Answer 1

Here's a skeleton for a service class that does something every minute, using a System.Timers.Timer:

public partial class XService : ServiceBase
{
    private Timer _minute = new Timer(60000);

    public XService()
    {
        InitializeComponent();

        _minute.Elapsed += Minute_Elapsed;
    }

    //this is async because my 'stuff' is async
    private async void Minute_Elapsed(object sender, ElapsedEventArgs e)
    {
        _minute.Stop();
        try
        {
            //stuff
        }
        catch (Exception ex)
        {
            //log ?
        }
        finally
        {
            _minute.Start();
        }
    }

    protected override void OnStart(string[] args)
    {
        _minute.Start();            //this or..

        Minute_Elapsed(null, null); //..this, if you want to do the things as soon as the service starts (otherwise the first tick will be a minute after start is called
    }

 ...

I typically stop my timers while I do my thing - no point starting a job that takes 10 minutes and then another one a minute later, hence the stop/try/finally/start pattern

Edit:

Here's the tail part of the class and how it's started/launched both in debug (inside visual studio) and in release (as an installed windows service):

        //just an adapter method so we can call OnStart like the service manager does, in a debugging context
        public void PubOnStop()
        {
            OnStop();
        }
    }// end of XService class

        static void Main(string[] args)
        {
#if DEBUG
            new XService().PubStart(args);
            Thread.Sleep(Timeout.Infinite);
#else

            ServiceBase[] ServicesToRun;
            ServicesToRun = new ServiceBase[]
            {
                new XService()
            };
            ServiceBase.Run(ServicesToRun);
#endif
        }