Comment appeler une méthode au quotidien, au moment précis, en C#?

• Créer une application console qui fait ce que vous êtes à la recherche pour
• Utiliser Windows "Tâches Planifiées la fonctionnalité" d'avoir cette console application exécutée au moment où vous en avez besoin pour exécuter

C'est vraiment tout ce dont vous avez besoin!

Mise à jour: si vous voulez le faire à l'intérieur de votre application, vous avez plusieurs options:

• dans un Windows Forms application, vous pourrez puiser dans la Application.Idle événement et vérifier pour voir si vous avez atteint le temps dans la journée pour appeler votre méthode. Cette méthode n'est appelée que lorsque votre application n'est pas occupé avec d'autres choses. Une vérification rapide pour voir si votre cible a été atteinte ne faut pas mettre trop de stress sur votre application, je pense...
• dans un ASP.NET web app, il existe des méthodes pour "simuler" l'envoi d'événements programmés - découvrez ce CodeProject article
• et bien sûr, vous pouvez aussi tout simplement "rouler" en tout .NET app - découvrez ce CodeProject article pour un exemple de mise en œuvre

Mise à jour #2: si vous voulez vérifier toutes les 60 minutes, vous pouvez créer un timer qui se réveille toutes les 60 minutes et si le temps est écoulé, il appelle la méthode.

Quelque chose comme ceci:

using System.Timers;

const double interval60Minutes = 60 * 60 * 1000; //milliseconds to one hour

Timer checkForTime = new Timer(interval60Minutes);
checkForTime.Elapsed += new ElapsedEventHandler(checkForTime_Elapsed);
checkForTime.Enabled = true;

et puis dans votre gestionnaire d'événement:

void checkForTime_Elapsed(object sender, ElapsedEventArgs e)
{
    if (timeIsReady())
    {
       SendEmail();
    }
}

Comme d'autres l'ont dit, vous pouvez utiliser une console application à exécuter lors de la planification. Ce que les autres n'ont pas dit, c'est que vous pouvez cette application déclencher un processus croisé EventWaitHandle qui vous attendent dans votre application principale.

Application Console:

class Program
{
    static void Main(string[] args)
    {
        EventWaitHandle handle = 
            new EventWaitHandle(true, EventResetMode.ManualReset, "GoodMutexName");
        handle.Set();
    }
}

Application Principale:

private void Form1_Load(object sender, EventArgs e)
{
    //Background thread, will die with application
    ThreadPool.QueueUserWorkItem((dumby) => EmailWait());
}

private void EmailWait()
{
    EventWaitHandle handle = 
        new EventWaitHandle(false, EventResetMode.ManualReset, "GoodMutexName");

    while (true)
    {
        handle.WaitOne();

        SendEmail();

        handle.Reset();
    }
}

La meilleure méthode que je connais et probablement le plus simple est d'utiliser le Planificateur de Tâches de Windows pour exécuter votre code à un moment précis de la journée ou avez-vous l'exécution de l'application en permanence et vérifier un moment particulier de la journée ou de rédiger un service windows qui en fait de même.

Si vous voulez un exécutable à exécuter, utiliser les Tâches Planifiées de Windows. Je vais supposer (peut-être à tort) que vous voulez une méthode à exécuter dans votre programme actuel.

Pourquoi ne pas simplement avoir un thread en cours d'exécution en continu le stockage de la dernière date à laquelle la méthode a été appelée?

L'avoir réveiller toutes les minutes (par exemple) et, si l'heure actuelle est plus grande que le temps spécifié et la dernière date enregistrée n'est pas la date du jour, l'appel à la méthode, puis mise à jour de la date.

Récemment, j'ai écrit une application en c# qui avait pour redémarrer tous les jours. Je me rends compte que cette question est vieux, mais je ne pense pas que ça fait mal d'en ajouter une autre solution possible. C'est de cette façon que j'ai manipulé quotidiennement redémarre à une heure spécifiée.

public void RestartApp()
{
  AppRestart = AppRestart.AddHours(5);
  AppRestart = AppRestart.AddMinutes(30);
  DateTime current = DateTime.Now;
  if (current > AppRestart) { AppRestart = AppRestart.AddDays(1); }

  TimeSpan UntilRestart = AppRestart - current;
  int MSUntilRestart = Convert.ToInt32(UntilRestart.TotalMilliseconds);

  tmrRestart.Interval = MSUntilRestart;
  tmrRestart.Elapsed += tmrRestart_Elapsed;
  tmrRestart.Start();
}

Pour assurer votre minuterie est conservé dans le champ d'application je vous recommande de créer en dehors de la méthode à l'aide de System.Timers.Timer tmrRestart = new System.Timers.Timer() méthode. Mettre la méthode RestartApp() dans votre événement load du formulaire. Au lancement de l'application il permettra de définir les valeurs pour AppRestart si current est plus grand que le redémarrage fois que nous ajoutons 1 jour à AppRestart pour assurer le redémarrage se produit dans les temps et que nous n'avons pas une exception pour mettre une valeur négative dans la minuterie. Dans le tmrRestart_Elapsed événement exécuter n'importe quel code vous avez besoin couru à ce moment précis. Si votre application redémarre tout seul, vous n'avez pas nécessairement à l'arrêt de la minuterie, mais il ne fait pas de mal non plus, Si l'application n'a pas redémarrer, il suffit d'appeler la RestartApp() méthode de nouveau et vous serez bon d'aller.

Plutôt que de fixer un temps pour s'exécuter à chaque seconde de toutes les 60 minutes, vous pouvez calculer le temps restant et réglez la minuterie à la moitié (ou fraction) de cette. De cette façon, votre pas de vérifier le temps, comme beaucoup, mais aussi maintianing un degré de accurcy que le minuteur d'intervalle réduit, plus vous vous rapprochez de votre objectif de temps.

Par exemple, si vous vouliez faire quelque chose de 60 minutes à partir de maintenant les minuteurs d'intervalles seraient aproximatly:

30:00:00, 15:00:00, 07:30:00, 03:45:00, ... , 00:00:01, RUN!

J'utilise le code ci-dessous pour redémarrer automatiquement un service une fois par jour. J'utilise un thread parce que j'ai trouvé des minuteries pour être peu fiable sur de longues périodes, alors que c'est plus cher dans cet exemple, il est le seul à créé à cet effet donc, ce dosn a pas d'importance.

(Converti à partir VB.NET)

autoRestartThread = new System.Threading.Thread(autoRestartThreadRun);
autoRestartThread.Start();

...

private void autoRestartThreadRun()
{
    try {
        DateTime nextRestart = DateAndTime.Today.Add(CurrentSettings.AutoRestartTime);
        if (nextRestart < DateAndTime.Now) {
            nextRestart = nextRestart.AddDays(1);
        }

        while (true) {
            if (nextRestart < DateAndTime.Now) {
                LogInfo("Auto Restarting Service");
                Process p = new Process();
                p.StartInfo.FileName = "cmd.exe";
                p.StartInfo.Arguments = string.Format("/C net stop {0} && net start {0}", "\"My Service Name\"");
                p.StartInfo.LoadUserProfile = false;
                p.StartInfo.UseShellExecute = false;
                p.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
                p.StartInfo.CreateNoWindow = true;
                p.Start();
            } else {
                dynamic sleepMs = Convert.ToInt32(Math.Max(1000, nextRestart.Subtract(DateAndTime.Now).TotalMilliseconds / 2));
                System.Threading.Thread.Sleep(sleepMs);
            }
        }
    } catch (ThreadAbortException taex) {
    } catch (Exception ex) {
        LogError(ex);
    }
}

Remarque, j'ai mis un faibles intervalle de 1000 ms, ce qui pourrait être increaded, réduite ou supprimée en fonction de la accurcy vous avez besoin.

N'oubliez pas aussi d'arrêter votre thread/minuterie lorsque votre application se ferme.

24 heures de temps de

var DailyTime = "16:59:00";
            var timeParts = DailyTime.Split(new char[1] { ':' });

            var dateNow = DateTime.Now;
            var date = new DateTime(dateNow.Year, dateNow.Month, dateNow.Day,
                       int.Parse(timeParts[0]), int.Parse(timeParts[1]), int.Parse(timeParts[2]));
            TimeSpan ts;
            if (date > dateNow)
                ts = date - dateNow;
            else
            {
                date = date.AddDays(1);
                ts = date - dateNow;
            }

            //waits certan time and run the code
            Task.Delay(ts).ContinueWith((x) => OnTimer());

public void OnTimer()
    {
        ViewBag.ErrorMessage = "EROOROOROROOROR";
    }