المؤقّت Timer في C#: System.Threading.Timer وSystem.Timers.Timer وPeriodicTimer

يشغّل المؤقّت (timer) شيفرة بعد تأخير أو على فاصل متكرر: تحديث ذاكرة مؤقتة كل دقيقة، أو حفظ مسودة كل 30 ثانية، أو استطلاع خدمة، أو تحديث ساعة. في .NET عدة أصناف مؤقّتات تبدو متشابهة لكنها تختلف في مكان تنفيذ دالة الاستدعاء الراجع وفي طريقة التحكم فيها. تغطي هذه الصفحة كلًّا منها، إضافة إلى Stopwatch لقياس المدة التي استغرقها شيء ما.

أي مؤقّت تستخدم

يُطلق الأوّلان على خيوط مجمّع الخيوط، فيمكن أن تعمل استدعاءاتهما في الوقت نفسه مع بقية برنامجك، وحتى في الوقت نفسه مع بعضها. أما مؤقّتات الواجهة فتعمل على خيط الواجهة، ولهذا تستطيع لمس عناصر التحكم مباشرة، ولهذا يجمّد المعالج البطيء النافذة.

System.Threading.Timer

يأخذ المُنشئ دالة الاستدعاء الراجع، وكائن حالة، والتأخير قبل النبضة الأولى، والدورة. ويبدأ فورًا.

using System;
using System.Diagnostics;
using System.Threading;

class Program
{
    static Timer timer;                  // a field keeps the timer alive
    static int ticks = 0;
    static Stopwatch clock = Stopwatch.StartNew();
    static ManualResetEvent done = new ManualResetEvent(false);

    static void OnTick(object state)
    {
        int n = Interlocked.Increment(ref ticks);
        Console.WriteLine("tick " + n + " at ~" + clock.ElapsedMilliseconds / 100 * 100 + " ms");
        if (n == 4)
        {
            timer.Change(Timeout.Infinite, Timeout.Infinite); // stop further ticks
            done.Set();
        }
    }

    static void Main()
    {
        // first tick after 200 ms, then every 300 ms
        timer = new Timer(OnTick, null, 200, 300);
        done.WaitOne();                  // keep Main alive until the 4th tick
        timer.Dispose();
        Console.WriteLine("stopped after " + ticks + " ticks");
    }
}

مخرجات على سبيل المثال:

tick 1 at ~200 ms
tick 2 at ~500 ms
tick 3 at ~800 ms
tick 4 at ~1100 ms
stopped after 4 ticks

تفصيلان مهمان هنا. يجب أن تنتظر Main (done.WaitOne())؛ فبرنامج الكونسول ينتهي حين تعود Main، واستدعاءات المؤقّت تعمل على خيوط خلفية لا تبقي العملية حية. والمؤقّت يعيش في حقل ساكن: System.Threading.Timer الذي لا يشير إليه شيء يمكن جمعه كنفايات، وعندها يتوقف عن الإطلاق بصمت. وهذا يلدغ أكثر ما يلدغ حين يُنشأ مؤقّت كمتغيّر محلي داخل دالة تعود.

تعيد Change(dueTime, period) جدولة المؤقّت؛ وTimeout.Infinite للاثنين توقفه مؤقتًا، وزوج جديد يعيد تشغيله. وتوقفه Dispose() نهائيًا.

System.Timers.Timer

يغلّف System.Timers.Timer الآلية نفسها في واجهة قائمة على الأحداث: اضبط Interval، واشترك في Elapsed، ثم Start() وStop().

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        int saves = 0;
        var autosave = new System.Timers.Timer(250);   // interval in ms
        var finished = new ManualResetEvent(false);

        autosave.Elapsed += (sender, e) =>
        {
            int n = Interlocked.Increment(ref saves);
            Console.WriteLine("autosave #" + n);
            if (n == 3)
            {
                autosave.Stop();
                finished.Set();
            }
        };
        autosave.AutoReset = true;   // repeat (the default); false fires once
        autosave.Start();

        finished.WaitOne();
        autosave.Dispose();
        Console.WriteLine("autosave stopped");
    }
}

مخرجات على سبيل المثال:

autosave #1
autosave #2
autosave #3
autosave stopped

تجعل AutoReset = false المؤقّت لمرة واحدة: يُطلق مرة ويتوقف، واستدعاء Start() مجددًا يجدول النبضة المفردة التالية. وEnabled = true وfalse مثل Start() وStop(). ويُكتب الاسم الكامل System.Timers.Timer هنا لأن في System.Threading أيضًا Timer؛ ومع استيراد فضاءي الأسماء يكون Timer المجرد ملتبسًا ولا يُترجم.

لـ System.Timers.Timer أيضًا الخاصية SynchronizingObject التي تنقل Elapsed إلى خيط الواجهة في WinForms. عمليًا يكون مؤقّت إطار الواجهة نفسه أبسط لذلك.

الاستدعاءات تتداخل وتعمل على خيوط أخرى

يُطلق الصنفان أعلاه على مجمّع الخيوط، في موعدهما، سواء انتهت دالة الاستدعاء السابقة أم لا. إن استغرقت دالة الاستدعاء 3 ثوانٍ وكانت الدورة ثانية واحدة، تعمل ثلاث استدعاءات معًا. وهذا يفرض التزامين:

• كل ما تلمسه دالة الاستدعاء الراجع يجب أن يكون آمنًا مع الخيوط. استخدم Interlocked للعدّادات (كما تفعل الأمثلة) وlock لأي شيء أكبر.
• احمِ من التداخل حين يهمّ ذلك. إما أن تتخطى نبضة ما دامت السابقة تعمل، أو تستخدم نمطًا لا يمكن أن يتداخل.

حارس تخطٍّ بـ Interlocked:

private int running = 0;

private void OnTick(object state)
{
    if (Interlocked.Exchange(ref running, 1) == 1) return; // previous tick still busy
    try
    {
        SyncOrders();   // slow work
    }
    finally
    {
        Volatile.Write(ref running, 0);
    }
}

الاستثناءات هي الفخ الآخر. الاستثناء الذي يفلت من دالة استدعاء System.Threading.Timer يُسقط العملية، بينما يبتلع System.Timers.Timer الاستثناءات من معالجات Elapsed فيمرّ الفشل دون ملاحظة. غلّف جسم دالة استدعاء المؤقّت في try/catch وسجّل.

PeriodicTimer والحلقات غير المتزامنة

في الشيفرة غير المتزامنة تكون الحلقة التي تنتظر بين التكرارات أوضح مؤقّت: لا يبدأ الانتظار التالي إلا بعد انتهاء العمل، فلا يمكن أن تتداخل النبضات أبدًا، وتظهر الاستثناءات حيث تستطيع التقاطها. أضافت .NET 6 النوع PeriodicTimer لهذا بالضبط:

using var timer = new PeriodicTimer(TimeSpan.FromSeconds(30));

while (await timer.WaitForNextTickAsync(cancellationToken))
{
    await SaveDraftAsync();
}

تعيد WaitForNextTickAsync القيمة false بمجرد التخلّص من المؤقّت، فتنتهي الحلقة، وترمي OperationCanceledException حين يُلغى الرمز. وبخلاف حلقة حول Task.Delay يحافظ PeriodicTimer على إيقاع ثابت: إن استغرق العمل ثانيتين تأتي النبضة التالية مع ذلك بعد 30 ثانية من السابقة، لا 32.

وفي أي إصدار يعمل الشكل نفسه مع Task.Delay حين لا يهمّ الانجراف:

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

class Program
{
    static async Task PollAsync(CancellationToken token)
    {
        int round = 0;
        try
        {
            while (true)
            {
                round++;
                Console.WriteLine("poll " + round);
                await Task.Delay(200, token);   // wait, or stop early on cancel
            }
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("polling cancelled after " + round + " rounds");
        }
    }

    static void Main()
    {
        using (var cts = new CancellationTokenSource(700))  // cancel after 700 ms
        {
            PollAsync(cts.Token).GetAwaiter().GetResult();
        }
    }
}

مخرجات على سبيل المثال:

poll 1
poll 2
poll 3
poll 4
polling cancelled after 4 rounds

يحلّ الإلغاء محل Stop(): مرّر رمزًا إلى الحلقة وألغه من الخارج. راجع المهام للمزيد عن رموز الإلغاء.

قياس الوقت المنقضي بـ Stopwatch

يجدول المؤقّت الشيفرة؛ ويقيس Stopwatch المدة التي استغرقتها الشيفرة. يقرأ ساعة عالية الدقة لا تتحرك إلا للأمام، وهذا يجعله الأداة الصحيحة للتوقيت:

using System;
using System.Diagnostics;
using System.Text;

class Program
{
    static void Main()
    {
        var sw = Stopwatch.StartNew();

        string s = "";
        for (int i = 0; i < 20000; i++) s += "x";      // slow: copies the string each time
        sw.Stop();
        Console.WriteLine("string +=      " + sw.ElapsedMilliseconds + " ms");

        sw.Restart();
        var sb = new StringBuilder();
        for (int i = 0; i < 20000; i++) sb.Append("x");
        string built = sb.ToString();
        sw.Stop();
        Console.WriteLine("StringBuilder  " + sw.ElapsedMilliseconds + " ms");

        Console.WriteLine("Same length: " + (s.Length == built.Length));
        Console.WriteLine("High resolution clock: " + Stopwatch.IsHighResolution);
    }
}

مخرجات على سبيل المثال:

string +=      64 ms
StringBuilder  0 ms
Same length: True
High resolution clock: True

تتحكم فيه Start وStop وReset وRestart؛ وElapsed من نوع TimeSpan، وتعطي ElapsedMilliseconds وElapsedTicks أرقامًا خامًا. تجنّب التوقيت بـ DateTime.Now: قد تكون دقته خشنة حتى 10 إلى 15 ms، ويقفز حين تُعدَّل ساعة النظام. وللمقاييس المعيارية الجادة، حيث يشوّه إحماء JIT وجمع النفايات تشغيلًا واحدًا، استخدم مكتبة BenchmarkDotNet.

دقة المؤقّت

فاصل المؤقّت حد أدنى لا وعد. على Windows تبلغ دقة مؤقّت النظام الافتراضية نحو 15.6 ms، فيميل فاصل 10 ms إلى الإطلاق كل 15 أو 16 ms، وعلى جهاز مشغول قد تبدأ دالة استدعاء مجمّع الخيوط أبعد من ذلك. المؤقّتات مناسبة لـ "نحو كل N ثانية". أما لتوقيت الإطارات الدقيق أو الوسائط فاستخدم واجهات API مبنية لذلك.

أخطاء شائعة

• System.Threading.Timer مخزّن في متغيّر محلي فقط. قد يُجمع كنفايات ويتوقف عن الإطلاق؛ احتفظ به في حقل.
• ترك Main تعود. تنتهي العملية وتأخذ المؤقّت معها.
• Timer الملتبس. مع استيراد System.Threading وSystem.Timers كليهما اكتب الاسم الكامل.
• افتراض أن النبضات لا تتداخل أبدًا. مؤقّتات مجمّع الخيوط تتداخل حين يكون العمل أبطأ من الفاصل.
• لمس عناصر تحكم الواجهة من مؤقّت مجمّع الخيوط. استخدم مؤقّت إطار الواجهة أو انقل التنفيذ إلى خيط الواجهة.
• الاستثناءات غير المعالجة في الاستدعاءات. تُسقط العملية (Threading.Timer) أو تختفي (Timers.Timer)؛ التقطها وسجّلها.
• نسيان Dispose. تمسك المؤقّتات موارد النظام وتستمر في الإطلاق حتى يُتخلّص منها.