private System.Timers.Timer timer=null;

public scheduler() {

string servicepollinterval = System.Configuration.ConfigurationSettings.AppSettings
["servicepollinterval"];

	double interval=10000;
	try {
		interval = Convert.ToDouble(servicepollinterval);
	}catch(Exception) {}
	
timer = new System.Timers.Timer(interval);
	timer.Elapsed += new ElapsedEventHandler( this.ServiceTimer_Tick );

}

System.Configuration.ConfigurationSettings.AppSettings
["servicepollinterval"];

timer.Elapsed += new ElapsedEventHandler( this.ServiceTimer_Tick );

protected override void OnStart(string[] args) {
	timer.AutoReset = true;
	timer.Enabled=true;
	timer.Start();
}

protected override void OnStop() {
	timer.AutoReset = false;
	timer.Enabled = false;
}	

Optionally you can define the OnPause and OnContinue members:

protected override void OnPause() {
	this.timer.Stop();
}

protected override void OnContinue() {
	this.timer.Start();
}

timer.Elapsed += new ElapsedEventHandler( this.ServiceTimer_Tick );

private void ServiceTimer_Tick(object sender, System.Timers.ElapsedEventArgs e) {
	this.timer.Stop();
	//IMPLEMENT YOUR TIMER TICK HERE
	this.timer.Start();
}

FileMonitor.cs
namespace FileMonitor
{
using System;
using System.Collections;
using System.Core;
using System.ComponentModel;
using System.Configuration;
using System.Data;
using System.Web.Services;
using System.Diagnostics;
using System.ServiceProcess;
using System.WinForms;
using System.IO;
using Microsoft.Win32.Interop;


public class WinService1 : System.ServiceProcess.ServiceBase
{

private System.ComponentModel.Container components;
private System.IO.FileSystemWatcher fileSystemWatcher1;
private ObjectList fileWatchers;

private System.Diagnostics.PerformanceCounter fDelCtr;
private System.Diagnostics.PerformanceCounter fCrCtr;

public WinService1()
{
// This call is required by the WinForms Component Designer.
InitializeComponent();

// TODO: Add any initialization after the InitComponent call

servicePaused = false;

this.CanPauseAndContinue = true;
this.CanStop = true;

}

// The main entry point for the process
static void Main()
{
System.ServiceProcess.ServiceBase[] ServicesToRun;

// More than one user Service may run within the same process. To add

ServicesToRun = new System.ServiceProcess.ServiceBase[] { new
WinService1() };
System.ServiceProcess.ServiceBase.Run(ServicesToRun);
}

/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.components = new System.ComponentModel.Container ();
this.fileSystemWatcher1 = new System.IO.FileSystemWatcher ();
fileSystemWatcher1.BeginInit ();

this.fDelCtr = new System.Diagnostics.PerformanceCounter ();
this.fCrCtr = new System.Diagnostics.PerformanceCounter ();

fileSystemWatcher1.Enabled = true;

fDelCtr.CategoryName = "FileMonitorService";
fCrCtr.CategoryName = "FileMonitorService";


fDelCtr.CounterName = "Files Deleted";
fCrCtr.CounterName = "Files Created";


this.ServiceName = "FileMonitor";
fileWatchers = new ObjectList();
fileSystemWatcher1.EndInit ();
}

/// <summary>
/// Set things in motion so your service can do its work.
/// </summary>
protected override void OnStart(string[] args)
{
string[] drives = Environment.GetLogicalDrives();

// create filesystem watchers for local fixed drives
foreach (string curDrive in drives )
{
if ( PlatformInvokeKernel32.GetDriveType(curDrive) == win.DRIVE_FIXED)
{
int item = fileWatchers.Add( new FileSystemWatcher() );
FileSystemWatcher curWatcher = (FileSystemWatcher)
fileWatchers[item];

curWatcher.BeginInit ();
curWatcher.Target = System.IO.WatcherTarget.File;
curWatcher.IncludeSubdirectories = true;
curWatcher.Path = curDrive;
curWatcher.Created += new FileSystemEventHandler(OnFileCreated);
curWatcher.Deleted += new FileSystemEventHandler(OnFileDeleted);
curWatcher.Enabled = true;
curWatcher.EndInit();
}
}
}

/// <summary>
/// Stop this service.
/// </summary>
protected override void OnStop()
{
// reset the counters back to 0

if( fDelCtr.RawValue != 0 )
{
fDelCtr.IncrementBy(-fDelCtr.RawValue);
}

if( fCrCtr.RawValue != 0 )
{
fCrCtr.IncrementBy(-fCrCtr.RawValue);
}
}

protected override void OnPause()
{
servicePaused = true;
}

protected override void OnContinue()
{
servicePaused = false;
}

private void OnFileCreated(Object source, FileSystemEvent

public class ProjectInstaller {

[RunInstaller(true)]  //**1**
	public class ProjectInstaller : System.Configuration.Install.Installer {  //**2**
	private System.ComponentModel.Container components;
	private System.ServiceProcess.ServiceInstaller serviceInstaller1; //**3**
	private System.ServiceProcess.ServiceProcessInstaller serviceProcessInstaller1; //**4**

		public ProjectInstaller() {
			InitializeComponent();
		}

	private void InitializeComponent() {
		this.serviceInstaller1 = new System.ServiceProcess.ServiceInstaller();
		this.serviceProcessInstaller1 = new System.ServiceProcess.ServiceProcessInstaller();

		this.serviceInstaller1.DisplayName = "Scheduler_Net";  //**5**
		this.serviceInstaller1.ServiceName = "Scheduler_Net";  //**6**

		this.serviceInstaller1.StartType = System.ServiceProcess.ServiceStartMode.Automatic;  //**7**

		this.serviceProcessInstaller1.Account = System.ServiceProcess.ServiceAccount.LocalSystem;  //**8**
		this.serviceProcessInstaller1.Password = null;  //**9**
		this.serviceProcessInstaller1.Username = null; 

		//**10**
		this.Installers.AddRange(new System.Configuration.Install.Installer[] {

	this.serviceProcessInstaller1,
	this.serviceInstaller1});
		}

	}
}

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <!-- application specific settings -->
  <configSections>
    <sectionGroup name="PlugInSettings">
      <!--notice we have an entry for each plugin's settings node below-->
        <section name="TemplatePluginSettings" type="System.Configuration.NameValueSectionHandler" />
    </sectionGroup>
  </configSections>
  
  <appSettings>
    <add key="servicepollinterval" value="10000" />       
  </appSettings>
  
  <PlugInSettings>
    <TemplatePluginSettings>
      <add key="whatever" value="whatever-value" />
    </TemplatePluginSettings>
  </PlugInSettings>
</configuration>

using System;

namespace ConsoleTimer
{
   /// <summary>
   /// Sample class for testing a server based timer.
   /// </summary>
   class Class1
   {
      System.Timers.Timer testTimer = new System.Timers.Timer();

      /// <summary>
      /// The main entry point for the application.
      /// </summary>
      [STAThread]
      static void Main(string[] args)
      {
         Class1 test = new Class1();
         test.testTimer.Enabled = true;
         test.testTimer.Interval = 5000;    // Execute timer every
                                            // five seconds
         test.testTimer.Elapsed += new
            System.Timers.ElapsedEventHandler(test.testTimer_Elapsed);

         // Sit and wait so we can see some output
         Console.ReadLine();
      }

      private void testTimer_Elapsed(object sender,
         System.Timers.ElapsedEventArgs e)
      {
         System.Console.WriteLine("myTimer event occurred");
      }
   }
}

using System;

namespace CodeGuru.TimerService
{
   /// <summary>
   /// Demonstrate the use of a timer.
   /// </summary>
   public class TimedItem
   {
      private System.Diagnostics.EventLog _AppEventLog;
      private System.Timers.Timer _Timer;

      private int _Interval = 30000;
      public int Interval
      {
         get { return this._Interval; }
         set { this._Interval = value; }
      }

      private string _Name = "";
      public string Name
      {
         get { return this._Name; }
         set { this._Name = value; }
      }

      /// <summary>
      /// Constructor
      /// </summary>
      public TimedItem(System.Diagnostics.EventLog AppEventLog)
      {
         this._Timer = new System.Timers.Timer();
         this._Timer.Elapsed += new
         System.Timers.ElapsedEventHandler(_Timer_Elapsed);
         this._Timer.Enabled = false;
         this._Timer.Interval = this.Interval;
         this._AppEventLog = AppEventLog;
      }

      /// <summary>
      /// Start the timer.
      /// </summary>
      public void StartTimer()
      {
         this._Timer.Enabled = true;
      }

      /// <summary>
      /// Stop the timer.
      /// </summary>
      public void StopTimer()
      {
         this._Timer.Enabled = false;
      }


      /*
       * Respond to the _Timer elapsed event.
       */
      private void _Timer_Elapsed(object sender,
         System.Timers.ElapsedEventArgs e)
      {
         this._AppEventLog.WriteEntry("Time elapsed for " + this.Name,
            System.Diagnostics.EventLogEntryType.Information);
      }
   }
}