Meilleure façon de faire une tâche en boucle le Service Windows

J'ai une méthode qui envoyer quelques SMS à nos clients que cherchez comme ci-dessous:

public void ProccessSmsQueue()
{
   SmsDbContext context = new SmsDbContext();
   ISmsProvider provider = new ZenviaProvider();
   SmsManager manager = new SmsManager(context, provider);

   try
   {
      manager.ProcessQueue();
   }
   catch (Exception ex)
   {
      EventLog.WriteEntry(ex.Message, EventLogEntryType.Error);
   }
   finally
   {
      context.Dispose();
   }
}

protected override void OnStart(string[] args)
{
   Task.Factory.StartNew(DoWork).ContinueWith( ??? )
}

J'ai donc quelques questions:

  1. Je ne sais pas combien de temps il faut pour la méthode à exécuter;

  2. La méthode peut lever des exceptions, que je veux écrire sur EventLog

  3. Je veux exécuter cette méthode en boucle, toutes les 10 min, mais seulement après la dernière exécution de la finition.

Comment je peux faire? J'ai pensé à utiliser ContinueWith(), mais j'ai encore des questions sur la façon de construire l'ensemble de la logique.

  • Pourquoi voulez-vous le faire à l'aide d'un Task à tous? Pourquoi ne pas utiliser un Timer?
  • À l'aide d'une minuterie, il faudrait que je contrôle le démarrage et l'arrêt à chaque fois que l'événement a été déclenché. J'ai pensé à cette solution, mais elle ne semble pas la plus élégante.
  • Qu'en est simplement à l'aide d'une boucle?
  • Car il sera exécuté de manière synchrone. J'ai besoin d'un mélange de async/sync.
InformationsquelleAutor GuFigueiredo | 2014-11-28
  1. 30

    Vous devriez avoir une méthode asynchrone qui accepte un CancellationToken de sorte qu'il sait quand s'arrêter, les appels ProccessSmsQueue dans un try-catch bloc et utilise Task.Delay asynchrone attendre jusqu'à ce que la prochaine fois il a besoin pour fonctionner:

    public async Task DoWorkAsync(CancellationToken token)
{
    while (true)
    {
        try
        {
            ProccessSmsQueue();
        }
        catch (Exception e)
        {
            //Handle exception
        }
        await Task.Delay(TimeSpan.FromMinutes(10), token);
    }
}

    Vous pouvez appeler cette méthode de démarrage de votre application, et Task.Wait le retour de la tâche avant de l'existant, de sorte que vous savez qu'il remplit, et n'a pas d'exceptions:

    private Task _proccessSmsQueueTask;
private CancellationTokenSource _cancellationTokenSource;

protected override void OnStart(string[] args)
{
    _cancellationTokenSource = new CancellationTokenSource();
    _proccessSmsQueueTask = Task.Run(() => DoWorkAsync(_cancellationTokenSource.Token));
}

protected override void OnStop()
{
    _cancellationTokenSource.Cancel();
    try
    {
        _proccessSmsQueueTask.Wait();
    }
    catch (Exception e)
    {
        //handle exeption
    }
}
    • A l'air sympa! Comment j'ai pu démarrer la Tâche dans ce scénario dans un Service Windows?
    • Démarrer, lorsque les charges de service et d'attendre pour lui quand il se ferme.
    • La méthode OnStop sur le WinService n'est pas asynchrone (ne peut pas utiliser les attendent). Si je viens d'annuler le jeton, il va travailler ou je peux le faire d'une autre manière? lorsque j'utilise attendent _task, je reçois: "L'attendent opérateur ne peut être utilisé dans une méthode annotée avec async modificateur")
    • C'est l'un des rares cas où c'est ok pour bloquer de manière synchrone sur une opération asynchrone. Utilisation Task.Wait.
    • Intéressant. Donc, dans ce scénario, le retard ne fonctionne que lorsque la ProcessQueue() se termine? Je ne veux deux ou plus "ProccessQueues" exécuter en même temps.
    • yep.
    • vous solution a bien fonctionné. Mais lorsque je tente de démarrer le service avec une grande file d'attente, le service de blocage lors du chargement. Je reçois un "Timeout" message. Je pense que les choses se passent de manière synchrone. Des idées?
    • oui, une méthode asynchrone exécuter simultanément jusqu'à ce qu'un await est atteint, qui, dans votre cas, signifie qu'il s'exécute ProccessSmsQueue une fois. Vous pouvez résoudre que par le déchargement de ce travail pour un ThreadPool fil avec Task.Run. J'ai mis à jour la réponse.
    • Qu'advient-il si nous mettons await DoWorkAsync(_cts.Token) au lieu de Task.Run(() => DoWorkAsync(_cts.Token)); dans la méthode OnStart ?
    • retourne void de sorte qu'il serait un async void méthode que vous devez utiliser uniquement pour les gestionnaires d'événements.
    • au début du processus, il peut se bloquer si cela prend trop de temps pour arriver à la première attendent. qui est l'endroit où Task.Run aide les cette réponse des informations utiles aswell
    • est _cts une faute de frappe? Je pense qu'il devrait être _cancellationTokenSource
    • fixe.

    InformationsquelleAutor i3arnon
  2. 1

    De l'échantillon dans la Catégorie des Travailleurs que j'ai utilisé dans les Services Windows. Il prend en charge l'arrêt dans un "propre" par l'utilisation d'un verrou.
    Vous n'avez qu'à ajouter votre code dans DoWork, réglez votre minuterie dans la StartTimerAndWork méthode (en millisecondes), et d'utiliser cette classe dans votre service. 

    public class TempWorker
{
private System.Timers.Timer _timer = new System.Timers.Timer();
private Thread _thread = null;
private object _workerStopRequestedLock = new object();
private bool _workerStopRequested = false;
private object _loopInProgressLock = new object();
private bool _loopInProgress = false;
bool LoopInProgress
{
get
{
bool rez = true;
lock (_loopInProgressLock)
rez = _loopInProgress;
return rez;
}
set
{
lock (_loopInProgressLock)
_loopInProgress = value;
}
}
#region constructors
public TempWorker()
{
}
#endregion
#region public methods
public void StartWorker()
{
lock (_workerStopRequestedLock)
{
this._workerStopRequested = false;
}
_thread = new Thread(new ThreadStart(StartTimerAndWork));
_thread.Start();
}
public void StopWorker()
{
if (this._thread == null)
return;
lock (_workerStopRequestedLock)
this._workerStopRequested = true;
int iter = 0;
while (LoopInProgress)
{
Thread.Sleep(100);
iter++;
if (iter == 60)
{
_thread.Abort();
}
}
//if (!_thread.Join(60000))
//   _thread.Abort();
}
#endregion
#region private methods
private void StartTimerAndWork()
{
this._timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
this._timer.Interval = 10000;//milliseconds
this._timer.Enabled = true;
this._timer.Start();
}
#endregion
#region event handlers
private void timer_Elapsed(object sender, ElapsedEventArgs e)
{
if (!LoopInProgress)
{
lock (_workerStopRequestedLock)
{
if (this._workerStopRequested)
{
this._timer.Stop();
return;
}
}
DoWork();
}
}
private void DoWork()
{
try
{
this.LoopInProgress = true;
//DO WORK HERE
}
catch (Exception ex)
{
//LOG EXCEPTION HERE
}
finally
{
this.LoopInProgress = false;
}
}
#endregion
}
    InformationsquelleAutor Adrian Nasui