EventWaitHandle。 阻塞 在C＃中设置唤醒计时器

Question

        using System;
        using System.Collections.Generic;
        using System.Linq;
        using System.Text;
        using System.Threading;
        using System.Runtime.InteropServices;
        using Microsoft.Win32.SafeHandles;
        using System.ComponentModel;
        using System.Windows.Forms;
        using System.Diagnostics;


        class WakeUp
        {
            [DllImport("kernel32.dll")]
            public static extern SafeWaitHandle CreateWaitableTimer(IntPtr lpTimerAttributes, bool bManualReset, string lpTimerName);

            [DllImport("kernel32.dll", SetLastError = true)]
            [return: MarshalAs(UnmanagedType.Bool)]
            public static extern bool SetWaitableTimer(SafeWaitHandle hTimer, [In] ref long pDueTime, int lPeriod, IntPtr pfnCompletionRoutine, IntPtr lpArgToCompletionRoutine, bool fResume);

            //tmParam will be converted to the proper data type inside
            //the class. Just send DateTime with the correct WakeUp time
            //As the only param to the constructor of WakeUp
            public WakeUp(DateTime tmParam)
            {
                //Create a new thread to set the waitable timer
                //setWaitable(tmParam);
                Debug.Print("Starting thread...");

                Thread t = new Thread( () => setWaitable(tmParam) );
                t.Start();

            }

            static void setWaitable(DateTime smParam)
            {
                long waketime = smParam.ToFileTime();

                using (SafeWaitHandle handle = CreateWaitableTimer(IntPtr.Zero, true, DateTime.Now.ToString()))
                {
                    //I need to try starting this block in a new thread since there is some blocking going on
                    //to set the waitable timer
                    if (SetWaitableTimer(handle, ref waketime, 0, IntPtr.Zero, IntPtr.Zero, true))
                    {
                        using (EventWaitHandle wh = new EventWaitHandle(false, EventResetMode.AutoReset))
                        {
                            wh.SafeWaitHandle = handle;
                            wh.WaitOne();
                            Debug.Print("TimerSet "+smParam.ToString());
                        }
                    }
                    else
                    {
                        throw new Win32Exception(Marshal.GetLastWin32Error());
                    }
                }
            }
        }

The new thread is created however:

    Debug.Print("TimerSet "+smParam.ToString());

never gets printed to the output window. It is possible to change the constructor to:

            public WakeUp(DateTime tmParam)
            {
                //Create a new thread to set the waitable timer
                //setWaitable(tmParam);
                Debug.Print("Starting thread...");

                 setWaitable(tmParam);
            } 

however this will block the current thread which takes approx two minutes or less but it works every time. I was thinking to move things onto its own thread.

For some reason the first way I posted when creating a new thread EventWaitHandle doesn't ever seem to come back. Its just blocking forever I think. Could this be a security issue between threads?

Just to clarify I am calling like:

    WakeUp test1 = new wakeUp(DateTime.Now.AddMinutes(2));

Thank you...

Answer 1

  new wakeUp(DateTime.Now.AddMinutes(2)

The pDueTime argument of SetWaitableTimer() can be incremental or absolute. You specify an incremental value by passing a negative value. But you are using a positive value so you get absolute time. Clearly you'd be ahead if you use an incremental value since that's what you really want. Use the TimeSpan.Ticks property.

Using absolute time is okay, but when you are in Rome then you have to act like a Roman, the operating system's clock runs on UTC. Local time is only for humans. From the MSDN article for SetWaitableTimer:

The time after which the state of the timer is to be set to signaled, in 100 nanosecond intervals. Use the format described by the FILETIME structure. Positive values indicate absolute time. Be sure to use a UTC-based absolute time , as the system uses UTC-based time internally. Negative values indicate relative time. The actual timer accuracy depends on the capability of your hardware. For more information about UTC-based time, see System Time.

You must use DateTime.UtcNow

Answer 2

Why are you creating a new thread for the timer? The whole point of timers, WaitableTimer included, is that you create the timer object and it notifies you asynchronously (by calling a callback function on a separate thread). when the timer period has elapsed. In that regard, WaitableTimer is no different than the .NET timer object System.Threading.Timer . In the case of WaitableTimer , you can have it signal an event, which is a handy thing.

Some years ago I wrote an article about using the WaitableTimer from C#. Unfortunately, the site that hosted the article is no longer in existence. The code is available, with examples, from http://mischel.com/pubs/waitabletimer.zip .

You probably want to review the Thread Timer Example , which shows how timers are typically used. The mechanism for the WaitableTimer is slightly different, but the concepts are the same.