fond travailleur avec le service windows

De la minuterie est le choix le plus adapté. J'ai légèrement d'une version améliorée qui prend soin de l'arrêt de la minuterie dans la méthode OnStop.

dans votre programme.cs, je voudrais faire les choses suivantes pour faire un débogage plus facile:

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceProcess;
using System.Text;
using System.Threading;

namespace SampleWinSvc
{
  static class Program
  {
    ///<summary>
    ///The main entry point for the application.
    ///</summary>
    static void Main()
    {
#if (!DEBUG)
      ServiceBase[] ServicesToRun;
      ServicesToRun = new ServiceBase[] { new Service1() };
      ServiceBase.Run(ServicesToRun);
#else
      //Debug code: this allows the process to run 
      //as a non-service. It will kick off the
      //service start point, and then run the 
      //sleep loop below.
      Service1 service = new Service1();
      service.Start();
      //Break execution and set done to true to run Stop()
      bool done = false;
      while (!done)
        Thread.Sleep(10000);
      service.Stop();
#endif
    }
  }
}

Puis, dans votre Service1.cs code:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.ServiceProcess;
using System.Timers;
using System.Text;
namespace SampleWinSvc
{
public partial class Service1 : ServiceBase
{
///<summary>
///This timer willl run the process at the interval specified (currently 10 seconds) once enabled
///</summary>
Timer timer = new Timer(10000);
public Service1()
{
InitializeComponent();
}
protected override void OnStart(string[] args)
{
Start();
}
public void Start()
{
//point the timer elapsed to the handler
timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
//turn on the timer
timer.Enabled = true;
}
///<summary>
///This is called when the service is being stopped. 
///You need to wrap up pretty quickly or ask for an extension.
///</summary>
protected override void OnStop()
{
timer.Enabled = false;
}
///<summary>
///Runs each time the timer has elapsed. 
///Remember that if the OnStop turns off the timer, 
///that does not guarantee that your process has completed. 
///If the process is long and iterative, 
///you may want to add in a check inside it 
///to see if timer.Enabled has been set to false, or 
///provide some other way to check so that 
///the process will stop what it is doing.
///</summary>
///<param name="sender"></param>
///<param name="e"></param>
void timer_Elapsed(object sender, ElapsedEventArgs e)
{
MyFunction();
}
private int secondsElapsed = 0;
void MyFunction()
{
secondsElapsed += 10;
}
}
}

Par la définition de la #DEBUG var dans vos options de compilation que vous permettez-vous d'exécuter le code
en tant que programme, puis lorsque vous êtes prêt à tester votre arrêt logique, il suffit de briser tous et
jeu fait pour le vrai. J'ai été en utilisant cette méthode depuis des années avec beaucoup de succès.

Comme commenté dans le code, si vous faites n'importe quoi long de votre événement de minuterie, vous pouvez surveiller à partir de la OnStop pour s'assurer qu'il dispose de suffisamment de temps si l'arrêt au milieu de choses.

Une autre solution possible avec Backgroundworker:

public partial class Service1 : ServiceBase
{
private System.ComponentModel.BackgroundWorker bwMyWorker;
public Service1()
{
InitializeComponent();
}
protected override void OnStart(string[] args)
{
bwMyWorker = new BackgroundWorker();            
bwMyWorker.DoWork += delegate(object sender, DoWorkEventArgs workArgs)
{
//Endless loop
for (; ; )
{
//Your work... E.g. add()
System.Threading.Thread.Sleep(new TimeSpan(0, 5, 0)); //Pause for 5 min
}
};
bwMyWorker.RunWorkerAsync();
}