Courir une fois par jour

Est-il une méthode intelligente pour faire mon executeEveryDayMethod() exécute une fois par jour, sans avoir à impliquer le Windows TaskScheduler?

Ce qui concerne

/Anders

source d'informationauteur Anders R

c#scheduling

8

Prendre un coup d'oeil à quartz.net. C'est une planification bibliothèque .net.

Plus spécifiquement de prendre un coup d'oeil ici.

J'ai réalisé cela en procédant de la manière suivante...

Configurer un minuteur qui se déclenche toutes les 20 minutes (même si le timing est à vous - je besoin pour exécuter à plusieurs reprises tout au long de la journée).
sur chaque événement Tick, vérifier l'heure du système. Comparer le temps de la date prévue de l'exécution de votre méthode.
Si l'heure actuelle est inférieure à l'heure prévue, de vérifier dans certains stockage persistant pour obtenir la valeur date /heure de la dernière fois que la méthode a couru.
Si la méthode de la dernière exécution de plus de 24 heures, exécuter la méthode, et à ranger la date de ce retour à votre magasin de données
Si la méthode de la dernière exécution dans les dernières 24 heures, de l'ignorer.

HTH

*modifier - exemple de code en C# :: Note : pas testé...

using System;
using System.Collections.Generic;
using System.Text;
using System.Timers;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            Timer t1 = new Timer();
            t1.Interval = (1000 * 60 * 20); //20 minutes...
            t1.Elapsed += new ElapsedEventHandler(t1_Elapsed);
            t1.AutoReset = true;
            t1.Start();

            Console.ReadLine();
        }

        static void t1_Elapsed(object sender, ElapsedEventArgs e)
        {
            DateTime scheduledRun = DateTime.Today.AddHours(3);  //runs today at 3am.
            System.IO.FileInfo lastTime = new System.IO.FileInfo(@"C:\lastRunTime.txt");
            DateTime lastRan = lastTime.LastWriteTime;
            if (DateTime.Now > scheduledRun)
            {
                TimeSpan sinceLastRun = DateTime.Now - lastRan;
                if (sinceLastRun.Hours > 23)
                {
                    doStuff();
                    //Don't forget to update the file modification date here!!!
                }
            }
        }

        static void doStuff()
        {
            Console.WriteLine("Running the method!");
        }
    }
}

Si le temps lorsqu'il est exécuté n'est pas pertinent et peut être remis à zéro chaque fois que le programme démarre, vous pouvez simplement mettre une minuterie, ce qui est la chose la plus facile à faire. Si ce n'est pas acceptable que ça commence à devenir plus complexes, comme la solution présentée ici et qui n'est toujours pas à résoudre le problème de la persistance, vous avez besoin pour résoudre séparément si vous voulez vraiment faire ce que les Tâches Planifiées serait. J'aimerais vraiment examiner à nouveau si cela vaut la peine de passer par toutes les difficultés à reproduire parfaitement les bonnes fonctionnalités existantes.

Voici un une question relative à la (Exemple pris à partir de là).

using System;
using System.Timers;

public class Timer1
{
    private static Timer aTimer = new System.Timers.Timer(24*60*60*1000);

    public static void Main()
    {
        aTimer.Elapsed += new ElapsedEventHandler(ExecuteEveryDayMethod);
        aTimer.Enabled = true;

        Console.WriteLine("Press the Enter key to exit the program.");
        Console.ReadLine();
    }

    //Specify what you want to happen when the Elapsed event is 
    //raised.
    private static void ExecuteEveryDayMethod(object source, ElapsedEventArgs e)
    {
        Console.WriteLine("The Elapsed event was raised at {0}", e.SignalTime);
    }
}

0

Vous pourriez moment de la requête et de l'exécuter si votre délai de quelques temps, de cette façon, même si la machine que vous allez appeler la méthode ou l'utilisation d'une minuterie comme Vinko de la suggestion.

Mais la meilleure solution (comme pour les plus âgés CRON versions, de sorte que ses un schéma éprouvé) est d'avoir des données persistantes, avec la solution la moins chère que je pense dès maintenant un fichier vide, vérifier son dernier attribut modifié, et si il n'a pas été modifiés dans les dernières 24 heures vous le touchez et exécuter votre méthode. De cette façon, vous assurer que la méthode est exécuté première chose dans le cas où la demande est pour le week-end par exemple.

Je l'ai fait en C# à l'avant, mais sa a un an à un autre Travail, donc je n'ai pas le code, mais il était d'environ 20 lignes (avec des commentaires et tout et tout).
0

Il peut y avoir des problèmes si le redémarrage de l'ordinateur de sorte que vous pourriez exécuter l'application en tant que service windows.
0

Pour exécuter le travail une fois par jour entre 7 et 8 heures du soir, j'ai mis en place un chronomètre avec un intervalle = 3600000 ms, puis exécutez simplement le code suivant pour timer tick.
```
private void timer1_Tick(object sender, EventArgs e)
{
    //ensure that it is running between 7-8pm daily.
    if (DateTime.Now.Hour == 19)
    { 
        RunJob(); 
    }
 }
```
Une heure de fenêtre est très bien pour moi. Extra granularité sur le temps aura besoin d'un plus petit intervalle sur la minuterie (60000 pendant une minute) et notamment les procès-verbaux sur le si.

par exemple
```
{
    //ensure that it is running at 7:30pm daily.
    if (DateTime.Now.Hour == 19 && DateTime.Now.Minute == 30)
    { 
        RunJob(); 
    }
 }
```
0

Si vous ne voulez exécuter une fois par jour et ne se soucient pas quand, ce sera du travail (va courir juste après minuit).

Déclarer un DateTime variable:
```
DateTime _DateLastRun;
```
Dans votre démarrage, la date de valeur:
```
_DateLastRun = DateTime.Now.Date;
```
Dans la logique de la zone où vous voulez vérifier si à effectuer l'action:
```
if (_DateLastRun < DateTime.Now.Date) 
{
    //Perform your action
    _DateLastRun= DateTime.Now.Date;
}
```

Vous devez vous connecter pour publier un commentaire.