hintergrund-Arbeiter-mit-windows-Dienst

Den timer, den richtigen Weg zu gehen. Ich habe eine leicht verbesserte version, der kümmert sich um die Abschaltung des Timers in der OnStop-Methode.

in Ihrem Programm.cs, ich würde Folgendes tun, um das Debuggen einfacher:

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
    }
  }
}

Dann in die 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;
        }
    }
}

Durch die Einstellung der #DEBUG var in Ihre Compiler-Optionen, die Sie sich erlauben, um den code auszuführen
als ein Programm, und dann, wenn Sie bereit sind, testen Sie Ihr shutdown-Logik, brechen einfach alle und
set fertig auf true. Ich habe mit dieser Methode seit Jahren mit viel Erfolg.

Als Kommentare im code, wenn Sie dabei sind etwas langwierig in Ihrer timer-Ereignis, dann möchten Sie vielleicht, um es überwachen von OnStop um sicherzustellen, dass es genug Zeit hat, wenn beim Herunterfahren in der Mitte der Dinge.

InformationsquelleAutor Robb Sadler

Andere Lösung mit der Backgroundworker-Klasse:

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();
    }

InformationsquelleAutor vanos