C # में, विशिष्ट समय पर, दैनिक तरीके से कॉल कैसे करें?

Question 1

मैंने SO पर खोज की है और Quartz.net के बारे में उत्तर पाए हैं। लेकिन यह मेरे प्रोजेक्ट के लिए बहुत बड़ा है। मैं एक समान समाधान चाहता हूं, लेकिन सरल और (सबसे अच्छा) इन-कोड (कोई बाहरी पुस्तकालय की आवश्यकता नहीं)। मैं एक विधि को एक विशिष्ट समय पर दैनिक कैसे कह सकता हूं?

मुझे इसके बारे में कुछ जानकारी जोड़ने की आवश्यकता है:

ऐसा करने का सबसे सरल (और बदसूरत) तरीका है, हर दूसरे / मिनट के समय की जाँच करें और सही समय पर विधि को कॉल करें

मैं ऐसा करने के लिए अधिक प्रभावी तरीका चाहता हूं, लगातार समय की जांच करने की कोई आवश्यकता नहीं है, और मेरे पास इस बारे में नियंत्रण है कि क्या नौकरी की जाती है या नहीं। यदि विधि विफल हो जाती है (किसी भी समस्या के कारण), प्रोग्राम को लॉग इन करने / ईमेल भेजने के लिए लिखना चाहिए। इसलिए मुझे एक विधि को कॉल करने की आवश्यकता है, न कि नौकरी शेड्यूल करने की।

मुझे यह समाधान मिला जावा में जावा में निश्चित समय पर एक विधि कॉल । क्या C # में भी ऐसा ही तरीका है?

संपादित करें: मैंने यह किया है। मैंने पैरामीटर को शून्य में जोड़ा) (), और इस पैरामीटर के साथ प्रोग्राम को चलाने के लिए एक बैट (विंडोज टास्क शेड्यूलर द्वारा निर्धारित) बनाया। कार्यक्रम चलता है, नौकरी करता है, और फिर बाहर निकलता है। यदि कोई नौकरी विफल हो जाती है, तो वह लॉग लिखने और ईमेल भेजने में सक्षम है। यह दृष्टिकोण मेरी आवश्यकताओं को अच्छी तरह से फिट बैठता है :)

Question 2

एक सांत्वना ऐप बनाएं जो आपको दिख रहा है
Windows " शेड्यूल किए गए कार्य " कार्यक्षमता का उपयोग करने के लिए उस कंसोल ऐप को उस समय निष्पादित किया जाता है जब आपको इसे चलाने की आवश्यकता होती है

यह वास्तव में आप सभी की जरूरत है!

अद्यतन: यदि आप अपने ऐप के अंदर ऐसा करना चाहते हैं, तो आपके पास कई विकल्प हैं:

एक विंडोज फॉर्म ऐप में, आप Application.Idleईवेंट में टैप कर सकते हैं और यह देखने के लिए देख सकते हैं कि क्या आप दिन में समय पर अपनी विधि को कॉल करने के लिए पहुंचे हैं। इस पद्धति को केवल तब कहा जाता है जब आपका ऐप अन्य सामानों के साथ व्यस्त न हो। एक त्वरित जाँच यह देखने के लिए कि क्या आपका लक्ष्य समय पूरा हो गया है, आपके ऐप पर बहुत अधिक तनाव नहीं होना चाहिए, मुझे लगता है ...
ASP.NET वेब ऐप में, अनुसूचित घटनाओं को बाहर भेजने के लिए "अनुकरण" करने के तरीके हैं - इस CodeProject लेख को देखें
और हां, आप किसी भी .NET ऐप में सिर्फ "अपना खुद का रोल" कर सकते हैं - एक नमूना कार्यान्वयन के लिए इस CodeProject लेख को देखें

अपडेट # 2 : यदि आप हर 60 मिनट की जांच करना चाहते हैं, तो आप एक टाइमर बना सकते हैं जो हर 60 मिनट में उठता है और यदि समय समाप्त हो जाता है, तो यह विधि को कॉल करता है।

कुछ इस तरह:

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;

और फिर अपने ईवेंट हैंडलर में:

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

Question 3

मैंने एक साधारण शेड्यूलर बनाया है जो उपयोग करने में आसान है और आपको बाहरी लाइब्रेरी का उपयोग करने की आवश्यकता नहीं है। टास्कसिड्यूलर एक सिंगलटन है जो टाइमर पर संदर्भ रखता है इसलिए टाइमर को एकत्र नहीं किया जाएगा, यह कई कार्यों को शेड्यूल कर सकता है। आप पहले रन (घंटे और मिनट) को सेट कर सकते हैं, अगर शेड्यूलिंग के समय यह समय उस दिन अगले दिन शेड्यूलिंग प्रारंभ से अधिक है। लेकिन कोड को कस्टमाइज़ करना आसान है।

किसी नए कार्य का निर्धारण करना बहुत सरल है। उदाहरण: 11:52 पर पहला कार्य प्रत्येक 15 सेकंड के लिए है, दूसरा उदाहरण प्रत्येक 5 सेकंड के लिए है। दैनिक निष्पादन के लिए 24 से 3 पैरामीटर सेट करें।

TaskScheduler.Instance.ScheduleTask(11, 52, 0.00417, 
    () => 
    {
        Debug.WriteLine("task1: " + DateTime.Now);
        //here write the code that you want to schedule
    });

TaskScheduler.Instance.ScheduleTask(11, 52, 0.00139,
    () =>
    {
        Debug.WriteLine("task2: " + DateTime.Now);
        //here write the code that you want to schedule
    });

मेरी डिबग विंडो:

task2: 07.06.2017 11:52:00
task1: 07.06.2017 11:52:00
task2: 07.06.2017 11:52:05
task2: 07.06.2017 11:52:10
task1: 07.06.2017 11:52:15
task2: 07.06.2017 11:52:15
task2: 07.06.2017 11:52:20
task2: 07.06.2017 11:52:25
...

इस श्रेणी को अपनी परियोजना में जोड़ें:

public class TaskScheduler
{
    private static TaskScheduler _instance;
    private List<Timer> timers = new List<Timer>();

    private TaskScheduler() { }

    public static TaskScheduler Instance => _instance ?? (_instance = new TaskScheduler());

    public void ScheduleTask(int hour, int min, double intervalInHour, Action task)
    {
        DateTime now = DateTime.Now;
        DateTime firstRun = new DateTime(now.Year, now.Month, now.Day, hour, min, 0, 0);
        if (now > firstRun)
        {
            firstRun = firstRun.AddDays(1);
        }

        TimeSpan timeToGo = firstRun - now;
        if (timeToGo <= TimeSpan.Zero)
        {
            timeToGo = TimeSpan.Zero;
        }

        var timer = new Timer(x =>
        {
            task.Invoke();
        }, null, timeToGo, TimeSpan.FromHours(intervalInHour));

        timers.Add(timer);
    }
}

Question 4

जब भी मैं ऐसी कार्यक्षमता की आवश्यकता वाले अनुप्रयोगों का निर्माण करता हूं, मैं हमेशा एक साधारण .NET लाइब्रेरी के माध्यम से विंडोज टास्क शेड्यूलर का उपयोग करता हूं जो मुझे मिला।

कृपया कुछ नमूना कोड और अधिक स्पष्टीकरण के लिए एक समान प्रश्न के लिए मेरा जवाब देखें ।

Question 5

जैसा कि दूसरों ने कहा है कि आप अनुसूचित होने पर चलाने के लिए कंसोल ऐप का उपयोग कर सकते हैं। दूसरों ने जो नहीं कहा है वह यह है कि आप इस एप्लिकेशन को एक क्रॉस प्रोसेस EventWaitHandle ट्रिगर कर सकते हैं जिसका आप अपने मुख्य एप्लिकेशन में इंतजार कर रहे हैं।

कंसोल ऐप:

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

मुख्य ऐप:

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

Question 6

सबसे अच्छी विधि जो मुझे पता है और शायद सबसे सरल है, दिन के किसी विशिष्ट समय में अपने कोड को निष्पादित करने के लिए विंडोज टास्क शेड्यूलर का उपयोग करना या क्या आपने आवेदन को स्थायी रूप से चलाया है और दिन के किसी विशेष समय के लिए जाँच करें या एक विंडोज़ सेवा लिखें। वही।

Question 7

मुझे पता है कि यह पुराना है लेकिन इस बारे में कैसे:

स्टार्टअप पर फायर करने के लिए टाइमर का निर्माण करें जो अगले रन टाइम के लिए समय की गणना करता है। रनटाइम के पहले कॉल पर, पहले टाइमर को रद्द करें और एक नया दैनिक टाइमर शुरू करें। प्रतिदिन प्रति घंटा या जो भी आप चाहते हैं कि आवधिकता में परिवर्तन हो।

Question 8

यहां टीपीएल का उपयोग करने का एक तरीका बताया गया है। टाइमर आदि बनाने / निपटाने की आवश्यकता नहीं:

void ScheduleSomething()
{

    var runAt = DateTime.Today + TimeSpan.FromHours(16);

    if (runAt <= DateTime.Now)
    {
        DoSomething();
    }
    else
    {
        var delay = runAt - DateTime.Now;
        System.Threading.Tasks.Task.Delay(delay).ContinueWith(_ => DoSomething());
    }

}

void DoSomething()
{
    // do somethig
}

Question 9

इस छोटे से कार्यक्रम का समाधान होना चाहिए ;-)

मुझे उम्मीद है कि इससे सभी को मदद मिलेगी।

using System;
using System.Threading;
using System.Threading.Tasks;

namespace DailyWorker
{
    class Program
    {
        static void Main(string[] args)
        {
            var cancellationSource = new CancellationTokenSource();

            var utils = new Utils();
            var task = Task.Run(
                () => utils.DailyWorker(12, 30, 00, () => DoWork(cancellationSource.Token), cancellationSource.Token));

            Console.WriteLine("Hit [return] to close!");
            Console.ReadLine();

            cancellationSource.Cancel();
            task.Wait();
        }

        private static void DoWork(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                Console.Write(DateTime.Now.ToString("G"));
                Console.CursorLeft = 0;
                Task.Delay(1000).Wait();
            }
        }
    }

    public class Utils
    {
        public void DailyWorker(int hour, int min, int sec, Action someWork, CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                var dateTimeNow = DateTime.Now;
                var scanDateTime = new DateTime(
                    dateTimeNow.Year,
                    dateTimeNow.Month,
                    dateTimeNow.Day,
                    hour,       // <-- Hour when the method should be started.
                    min,  // <-- Minutes when the method should be started.
                    sec); // <-- Seconds when the method should be started.

                TimeSpan ts;
                if (scanDateTime > dateTimeNow)
                {
                    ts = scanDateTime - dateTimeNow;
                }
                else
                {
                    scanDateTime = scanDateTime.AddDays(1);
                    ts           = scanDateTime - dateTimeNow;
                }

                try
                {
                     Task.Delay(ts).Wait(token);
                }
                catch (OperationCanceledException)
                {
                    break;
                }

                // Method to start
                someWork();
            }
        }
    }
}

Question 10

यदि आप चलाने के लिए एक निष्पादन योग्य चाहते हैं, तो विंडोज शेड्यूल किए गए कार्य का उपयोग करें। मैं मानने जा रहा हूं (शायद ग़लती से) कि आप अपने वर्तमान कार्यक्रम में एक विधि चलाना चाहते हैं।

क्यों न केवल एक थ्रेड चल रहा है जो अंतिम तिथि को संग्रहीत करता है जिसे विधि कहा जाता था?

क्या यह हर मिनट (उदाहरण के लिए) जागता है और, यदि वर्तमान समय निर्दिष्ट समय से अधिक है और संग्रहीत अंतिम तिथि वर्तमान तिथि नहीं है, तो विधि को कॉल करें फिर तिथि को अपडेट करें।

Question 11

यह सिर्फ मुझे हो सकता है लेकिन ऐसा लग रहा था कि इनमें से अधिकांश उत्तर पूर्ण नहीं थे या सही ढंग से काम नहीं करेंगे। मैंने कुछ बहुत जल्दी और गंदा कर दिया। यह कहा जाना सुनिश्चित नहीं है कि यह इस तरह से करना कितना अच्छा है, लेकिन यह हर बार पूरी तरह से काम करता है।

while (true)
{
    if(DateTime.Now.ToString("HH:mm") == "22:00")
    {
        //do something here
        //ExecuteFunctionTask();
        //Make sure it doesn't execute twice by pausing 61 seconds. So that the time is past 2200 to 2201
        Thread.Sleep(61000);
    }

    Thread.Sleep(10000);
}

Question 12

मैंने अभी हाल ही में एसी # एप लिखा है जिसे रोजाना रीस्टार्ट करना था। मुझे लगता है कि यह सवाल पुराना है, लेकिन मुझे नहीं लगता कि यह एक और संभव समाधान जोड़ने के लिए दर्द होता है। यह है कि मैं एक निर्दिष्ट समय पर दैनिक पुनरारंभ कैसे संभालता हूं।

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

यह सुनिश्चित करने के लिए कि आपके टाइमर को दायरे में रखा गया है, मैं इसे विधि का उपयोग करके System.Timers.Timer tmrRestart = new System.Timers.Timer()विधि के बाहर बनाने की सलाह देता हूं । विधि RestartApp()को अपने फ़ॉर्म लोड ईवेंट में रखें। आवेदन की शुरूआत में यह मान सेट करेगा जब के लिए AppRestartकरता है, तो currentपुनः आरंभ समय से अधिक है हम 1 दिन जोड़ने के लिए AppRestartसुनिश्चित करने के लिए पुनः आरंभ समय पर होता है और हम घड़ी में एक नकारात्मक मूल्य डालने के लिए एक अपवाद नहीं मिलता है कि। में tmrRestart_Elapsedघटना रन जो कुछ कोड आप उस विशिष्ट समय से चलता था की जरूरत है। यदि आपका एप्लिकेशन स्वयं चालू होता है, तो आपको टाइमर को बंद करने की आवश्यकता नहीं है, लेकिन यह या तो चोट नहीं पहुंचाता है, यदि एप्लिकेशन पुनरारंभ नहीं होता है तो बस RestartApp()विधि को फिर से कॉल करें और आप जाने के लिए अच्छा होगा।

Question 13

मुझे यह बहुत उपयोगी लगा:

using System;
using System.Timers;

namespace ScheduleTimer
{
    class Program
    {
        static Timer timer;

        static void Main(string[] args)
        {
            schedule_Timer();
            Console.ReadLine();
        }

        static void schedule_Timer()
        {
            Console.WriteLine("### Timer Started ###");

            DateTime nowTime = DateTime.Now;
            DateTime scheduledTime = new DateTime(nowTime.Year, nowTime.Month, nowTime.Day, 8, 42, 0, 0); //Specify your scheduled time HH,MM,SS [8am and 42 minutes]
            if (nowTime > scheduledTime)
            {
                scheduledTime = scheduledTime.AddDays(1);
            }

            double tickTime = (double)(scheduledTime - DateTime.Now).TotalMilliseconds;
            timer = new Timer(tickTime);
            timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
            timer.Start();
        }

        static void timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            Console.WriteLine("### Timer Stopped ### \n");
            timer.Stop();
            Console.WriteLine("### Scheduled Task Started ### \n\n");
            Console.WriteLine("Hello World!!! - Performing scheduled task\n");
            Console.WriteLine("### Task Finished ### \n\n");
            schedule_Timer();
        }
    }
}

Question 14

Windows टास्क शेड्यूलर का उपयोग करने का प्रयास करें। एक exe बनाएं जो किसी भी उपयोगकर्ता इनपुट के लिए संकेत नहीं दे रहा है।

https://docs.microsoft.com/en-us/windows/win32/taskschd/task-scheduler-start-page

Question 15

प्रत्येक 60 मिनट में से प्रत्येक को चलाने के लिए एक समय निर्धारित करने के बजाय आप शेष समय की गणना कर सकते हैं और टाइमर को इस के आधे (या कुछ अन्य अंश) पर सेट कर सकते हैं। इस तरह से आपके समय की अधिक जाँच नहीं हो रही है, लेकिन सटीक की एक डिग्री को भी मेनटेन कर रहा है क्योंकि टाइमर अंतराल आपके लक्ष्य समय के करीब पहुँचता है।

उदाहरण के लिए यदि आप अभी से कुछ 60 मिनट करना चाहते थे, तो समय अंतराल एक-दूसरे के बराबर होगा:

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

मैं दिन में एक बार किसी सेवा को स्वचालित रूप से पुनरारंभ करने के लिए नीचे दिए गए कोड का उपयोग करता हूं। मैं थ्रेड का उपयोग करता हूं क्योंकि मैंने लंबे समय से अविश्वसनीय पाया है, जबकि इस उदाहरण में यह अधिक महंगा है, यह केवल इस उद्देश्य के लिए बनाया गया है, इसलिए यह कोई फर्क नहीं पड़ता।

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

ध्यान दें, मैंने 1000 ms का मिनिनम अंतराल निर्धारित किया है, यह आपके द्वारा आवश्यक शुद्धता के आधार पर LGded, कम या हटाया जा सकता है।

जब आपका एप्लिकेशन बंद हो जाए तो अपने थ्रेड / टाइमर को बंद करना भी याद रखें।

Question 16

मेरे पास इसके लिए एक सरल तरीका है। यह कार्रवाई होने से पहले 1 मिनट की देरी पैदा करता है। आप थ्रेड्स बनाने के लिए कुछ सेकंड जोड़ सकते हैं। कम।

private void DoSomething(int aHour, int aMinute)
{
    bool running = true;
    while (running)
    {
        Thread.Sleep(1);
        if (DateTime.Now.Hour == aHour && DateTime.Now.Minute == aMinute)
        {
            Thread.Sleep(60 * 1000); //Wait a minute to make the if-statement false
            //Do Stuff
        }
    }
}

Question 17

24 घंटे का समय

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

Question 18

एक कार्य के लिए एक सरल उदाहरण:

using System;
using System.Timers;

namespace ConsoleApp
{
    internal class Scheduler
    {
        private static readonly DateTime scheduledTime = 
            new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 10, 0, 0);
        private static DateTime dateTimeLastRunTask;

        internal static void CheckScheduledTask()
        {
            if (dateTimeLastRunTask.Date < DateTime.Today && scheduledTime.TimeOfDay < DateTime.Now.TimeOfDay)
            {
                Console.WriteLine("Time to run task");
                dateTimeLastRunTask = DateTime.Now;
            }
            else
            {
                Console.WriteLine("not yet time");
            }
        }
    }

    internal class Program
    {
        private static Timer timer;

        static void Main(string[] args)
        {
            timer = new Timer(5000);
            timer.Elapsed += OnTimer;
            timer.Start();
            Console.ReadLine();
        }

        private static void OnTimer(object source, ElapsedEventArgs e)
        {
            Scheduler.CheckScheduledTask();
        }
    }
}

Question 19

System.Threading.Timer के साथ समाधान:

    private void nameOfMethod()
    {
        //do something
    }

    /// <summary>
    /// run method at 22:00 every day
    /// </summary>
    private void runMethodEveryDay()
    {
        var runAt = DateTime.Today + TimeSpan.FromHours(22);

        if(runAt.Hour>=22)
            runAt = runAt.AddDays(1.00d); //if aplication is started after 22:00 

        var dueTime = runAt - DateTime.Now; //time before first run ; 

        long broj3 = (long)dueTime.TotalMilliseconds;
        TimeSpan ts2 = new TimeSpan(24, 0, 1);//period of repeating method
        long broj4 = (long)ts2.TotalMilliseconds;
        timer2 = new System.Threading.Timer(_ => nameOfMethod(), null, broj3, broj4);
    }