WaitableTimer, вывод компьютера из спящего режима

using System;
using System.Threading;
using System.Runtime.InteropServices;

namespace Waitable
{
	public class WaitableTimer
	{
		[DllImport("kernel32.dll")]
		private static extern IntPtr CreateWaitableTimer(
			IntPtr lpTimerAttributes,
			bool bManualReset,
			string lpTimerName);
		[DllImport("kernel32.dll")]
		private static extern bool SetWaitableTimer(
			IntPtr hTimer,
			[In] ref long pDueTime,
			int lPeriod,
			IntPtr pfnCompletionRoutine,
			IntPtr lpArgToCompletionRoutine,
			bool fResume);
		[DllImport("kernel32", SetLastError = true, ExactSpelling = true)]
		private static extern Int32 WaitForSingleObject(IntPtr handle, uint milliseconds);

		private static IntPtr handle;
		private static Thread mainwait; // давайте жить дружно
		private static void SetWaitForWakeUpTime(object input)
		{
			long duetime=(long)input;
			input=null;
			handle=CreateWaitableTimer(IntPtr.Zero,true,"LOL_Bot_WaitableTimer");
			SetWaitableTimer(handle,ref duetime,0,IntPtr.Zero,IntPtr.Zero,true);
			uint INFINITE = 0xFFFFFFFF;
			int ret=WaitForSingleObject(handle,INFINITE);
			mainwait=null;
		}
		public static void SetWakeUp(TimeSpan delay)
		{
			mainwait=new Thread(WaitableTimer.SetWaitForWakeUpTime);
			mainwait.Start(-delay.Ticks);
		}
	}
}

using System;
using System.Text;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
using System.ComponentModel;
using System.Threading;

namespace WakeUPTimer
{
    public class Program
    {
        public static void Main()
        {
            var timer = new WakeUP();
            timer.Woken += Timer_Woken;
            timer.SetWakeUpTime(DateTime.Now.AddMinutes(2));
            Console.WriteLine("Go to sleep");
            Thread.Sleep(TimeSpan.FromMinutes(5));
            Console.WriteLine(nameof(Thread.Sleep));
            Console.ReadLine();
        }

        private static void Timer_Woken(object sender, EventArgs e)
        {
            Console.WriteLine(nameof(Timer_Woken));
        }
    }

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

        public event EventHandler Woken;

        private BackgroundWorker bgWorker = new BackgroundWorker();

        public WakeUP()
        {
            bgWorker.DoWork += new DoWorkEventHandler(bgWorker_DoWork);
            bgWorker.RunWorkerCompleted +=
              new RunWorkerCompletedEventHandler(bgWorker_RunWorkerCompleted);
        }

        public void SetWakeUpTime(DateTime time)
        {
            bgWorker.RunWorkerAsync(time.ToFileTime());
        }

        void bgWorker_RunWorkerCompleted(object sender,
                      RunWorkerCompletedEventArgs e)
        {
            if (Woken != null)
            {
                Woken(this, new EventArgs());
            }
        }

        private void bgWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            long waketime = (long)e.Argument;

            using (SafeWaitHandle handle =
                      CreateWaitableTimer(IntPtr.Zero, true,
                      this.GetType().Assembly.GetName().Name.ToString() + "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();
                    }
                }
                else
                {
                    throw new Win32Exception(Marshal.GetLastWin32Error());
                }
            }
        }

    }
}