Comment arrêter en toute sécurité un thread C # .NET s'exécutant dans un service Windows?

La mise en œuvre de soi-même est la seule option sûre. Même si vous trouvez un moyen de savoir si un thread est en veille, vous aurez toujours une condition de course si vous essayez de le tuer (parce qu'elle est susceptible de commencer à traiter une fois que vous vérifiez et avant de le tuer).

Au lieu de Fil.Le sommeil vous pourriez par exemple le sommeil 500ms et de vérifier si l'abandon du drapeau est toujours faux, le sommeil un autre 500ms etc. avant de 30mins passe, puis faire le travail, etc. (ce serait une approche pragmatique). Si vous voulez quelque chose de plus élégant, vous pouvez utiliser un ManualResetEvent avec un délai d'attente à attendre que le thread principal de signalisation que son temps pour abandonner.

Voici une façon de le faire. Ajouter les variables suivantes à votre classe:

private readonly object syncObject = new object();
private bool stopping;
private bool stopped = true;

Puis dans OnStart, vous faites quelque chose comme cela (j'ai une méthode d'assistance qui ne l'abattage dans cet exemple, et la "" la méthode le travail réel).:

    public override void OnStart()
    {
        while (stopping)
        {
            Thread.Sleep(MSECS_SLEEP_FOR_STOP);
        }

        lock (syncObject)
        {
            //make sure task isn't already started
            if (!stopped)
            {
                Helper.WriteToLog(logger, Level.INFO,
                    string.Format("{0} {1}", TASK_NAME, "is already started."));
                return;
            }
            stopped = false;
        }

        //start task in new thread
        Thread thread = new Thread(Run);
        thread.Start();

        Helper.WriteToLog(logger, Level.INFO,
            string.Format("{0} {1}", TASK_NAME, "was started."));
    }

Votre "Run" de la méthode, le travail du fil, ressemble à ceci (processInterval serait combien de temps vous voulez attendre entre les pistes, vous pouvez l'installer dans le constructeur ou simplement de coder en dur):

    private void Run()
    {
        try
        {
            while (!stopping)
            {
                //do work here

                //wait for process interval
                DateTime waitStart = DateTime.Now;
                while (((DateTime.Now - waitStart).TotalMilliseconds < processInterval) && !stopping)
                {
                    //give processing time to other threads
                    Thread.Sleep(MSECS_SLEEP_FOR_CHECK);
                }
            }
            lock (syncObject)
            {
                stopped = true;
                stopping = false;
            }

            Helper.WriteToLog(logger, Level.INFO,
                string.Format("{0} {1}", TASK_NAME, "was stopped."));
        }
        catch (Exception e)
        {
            //log the exception, but ignore it (i.e. don't throw it)
            Helper.LogException(logger, MethodBase.GetCurrentMethod(), e);
        }
    }

Puis dans OnStop, vous voulez faire cela:

    public override void OnStop()
    {
        lock (syncObject)
        {
            if (stopping || stopped)
            {
                Helper.WriteToLog(logger, Level.INFO,
                    string.Format("{0} {1}", TASK_NAME, "is already stopped."));
                return;
            }
            stopping = true;
        }
    }

Essayez d'utiliser un autoreset drapeau pour gérer l'arrêt du service. Dans ce cas, vous n'aurait pas à effectuer d'abandon de thread. Ont ajouté l'exemple de code ci-dessous

namespace WorkService
{
    public partial class WorkService : ServiceBase
    {
    AutoResetEvent serviceStopEvent = new AutoResetEvent( false);

        public WorkService()
        {
            InitializeComponent();
        }

        protected override void OnStart(string[] args)
        {
            Thread workerThread = new Thread(new ThreadStart(DoWork));
            workerThread.Start();
        }

        protected override void OnStop()
        {
           serviceStopEvent.Set();
        }

        static void DoWork()
        {
            int sleepMinutes = 30;
        WaitHandle[ ] handles = new WaitHandle[ ] { serviceStopEvent };

            while (WaitHandle.WaitAny( handles))
            {
                 ActualWorkDoneHere();

            }
        }

    }
}

Cheers,
Bharath.

while (true)
        {
            if (m_reset.WaitOne(1,false))
                break;
             //DoSomething


        }

Veuillez Essayer ceci à l'intérieur onStop()