public MFTestResults TimerTest0()
        {
            MFTestResults result = MFTestResults.Pass;
            try
            {
                timerEvent.Reset();
                /// Save the current time shifted by 5 hours.
                
                timerTime = DateTime.UtcNow - utcTimeShiftAmount;
                using (Timer t = new Timer(new TimerCallback(TimerCallback), null, new TimeSpan(0, 0, 30), new TimeSpan(-TimeSpan.TicksPerMillisecond)))
                {
                    /// We shift the utc back by 5 hours.
                    TimeService.SetUtcTime(timerTime.Ticks); 
                    
                    /// timer should still fire after 30 seconds even though absolute time has been manipulated.
                    if (!timerEvent.WaitOne(2 * 60 * 1000, false))
                    {
                        result = MFTestResults.Fail;
                    }

                    /// Reset the changes.
                    TimeService.SetUtcTime((DateTime.UtcNow + utcTimeShiftAmount).Ticks);

                    t.Change(-1, -1);
                }
            }
            catch (Exception ex)
            {
                Log.Exception("Unexpected exception", ex);
                result = MFTestResults.Fail;
            }

            return result;
        }

        public PythonInterpreterFactoryWithDatabase(
            Guid id,
            string description,
            InterpreterConfiguration config,
            bool watchLibraryForChanges
        ) {
            _description = description;
            _id = id;
            _config = config;

            if (watchLibraryForChanges && Directory.Exists(_config.LibraryPath)) {
                _refreshIsCurrentTrigger = new Timer(RefreshIsCurrentTimer_Elapsed);

                _libWatcher = CreateLibraryWatcher();

                _isCheckingDatabase = true;
                _refreshIsCurrentTrigger.Change(1000, Timeout.Infinite);

                _verWatcher = CreateDatabaseVerWatcher();
                _verDirWatcher = CreateDatabaseDirectoryWatcher();
            }

            // Assume the database is valid if the directory exists, then switch
            // to invalid after we've checked.
            _isValid = Directory.Exists(DatabasePath);
        }

 public Evictor(ConcurrentDictionary<string, ServerCacheItem> dictionary)
 {
     _cache = dictionary;
     _evictionPeriod = Convert.ToInt32(ConfigurationManager.AppSettings["EvictionPeriod"] ?? "60000");
     _evictionTimer = new Timer(AtEvictionPeriod, null, _evictionPeriod, _evictionPeriod);
     _evictionClass = ConfigurationManager.AppSettings["EvictionStrategyClass"] ?? "HoC.Server.Eviction.LRUEvictionStrategy";
 }

 public override int HandleInterrupt()
 {
     switch (AttachedCPU.A)
     {
         case 0:
             Frequency = AttachedCPU.B;
             if (Frequency != 0)
                 Clock = new Timer(Tick, null, (int)(1000 / (60d / Frequency)), Timeout.Infinite);
             else
             {
                 if (Clock != null)
                 {
                     Clock.Dispose();
                     Clock = null;
                 }
             }
             ElapsedTicks = 0;
             break;
         case 1:
             AttachedCPU.C = ElapsedTicks;
             break;
         case 2:
             InterruptMessage = AttachedCPU.B;
             break;
     }
     return 0;
 }

        public DiffPlexControl()
        {
            InitializeComponent();
            diffTimer = new Timer(DiffTimerCallback, null, 0, TimerPollFrequency);
            nonModifyingKeys =
                new List<Key>
                {
                    Key.LeftShift,
                    Key.RightShift,
                    Key.Up,
                    Key.Left,
                    Key.Right,
                    Key.Down,
                    Key.PageDown,
                    Key.PageUp,
                    Key.LeftAlt,
                    Key.RightAlt,
                    Key.CapsLock,
                    Key.LeftCtrl,
                    Key.RightCtrl,
                    Key.Escape
                };

            scrollSynchronizer = new ScrollViewerSynchronizer(LeftScroller, RightScroller);
            diffRenderer = new TextBoxDiffRenderer(LeftDiffGrid, LeftBox, RightDiffGrid, RightBox);
            Dispatcher.BeginInvoke((Action)diffRenderer.GenerateDiffView);
        }

		/// <summary>
		/// When implemented in a derived class, executes when a Start command is sent to the service by the Service Control Manager (SCM) or when the operating system starts (for a service that starts automatically). Specifies actions to take when the service starts.
		/// </summary>
		/// <param name="args">Data passed by the start command.</param>
		/// <exception cref="ServiceInitializationException">Initialize event not set</exception>
		protected override void OnStart(string[] args)
		{
			if (Initialize == null)
				throw new ServiceInitializationException("Initialize event not set");

			if (Initialize())
			{
				var runWorkingPointsTimer = false;

				foreach (var job in _jobsList)
				{
					if (job.WorkingPoints != null)
						runWorkingPointsTimer = true;
					else
						_jobsTimers.Add(new Timer(OnJobTimerTick, job, job.TimerDueTime, job.TimerPeriod));
				}

				if (runWorkingPointsTimer)
					_workingPointsTimer = new Timer(OnWorkingPointsTimerTick, null, 1000, 60000);

				base.OnStart(args);
			}
			else
			{
				ExitCode = 14001;	// Configuration is incorrect
				Stop();
			}
		}

 public void Initialize()
 {
     RefreshConfigData(false, CancellationToken.None);
     Plugin.Instance.ConfigurationUpdated += (sender, args) => RefreshConfigData(true, CancellationToken.None);
     _timerProvider.RestartTimers();
     _updateSeriesTimers = new Timer(UpdateSeriesTimersCallback, null, TimeSpan.FromHours(3), TimeSpan.FromHours(3));
 }

        public ApplePushChannel(ApplePushChannelSettings channelSettings)
        {
            cancelToken = cancelTokenSrc.Token;

            appleSettings = channelSettings;

            certificate = this.appleSettings.Certificate;

            certificates = new X509CertificateCollection();

            if (appleSettings.AddLocalAndMachineCertificateStores)
            {
                var store = new X509Store(StoreLocation.LocalMachine);
                certificates.AddRange(store.Certificates);

                store = new X509Store(StoreLocation.CurrentUser);
                certificates.AddRange(store.Certificates);
            }

            certificates.Add(certificate);

            if (this.appleSettings.AdditionalCertificates != null)
                foreach (var addlCert in this.appleSettings.AdditionalCertificates)
                    certificates.Add(addlCert);

            timerCleanup = new Timer(state => Cleanup(), null, TimeSpan.FromMilliseconds(1000), TimeSpan.FromMilliseconds(1000));
        }

        public DynamicRangeChunkVolume(GraphicsDevice device, GameDataProvider provider)
        {
            chunkWishList = new HashSet<WorldPosition>();
            this.provider = provider;
            volume = new Chunk[16, 16, 16];
            vertexBuffers = new CDictionary<Chunk, VBuffer7>();
            this.device = device;
            this.effect = Static.Effect;
            MiniMap = new Texture2D(Static.Device, 64, 64);
            MiniMapBuffer = new Color[64 * 64];
            MiniMapLayer = new Layer(MiniMap, 1, 0.7f, LayerDock.Far, LayerDock.Far,
                () =>
                {
                    return true;
                }
                );
            MiniMapLayer.Push(new LayerCell
            {
                SourceTexture = new Rectangle(0, 0, 64, 64),
                DestinationScreen = new Rectangle(-270, -270, 256, 256)
            });

            redrawWorker = new Timer(doRedraw);
            redrawWorker.Change(50, 50);

            hoverBoxMesh = HelpfulStuff.getCube(0.51f, GraphicsHelper.TextureCoord(36));
        }

 public TimeBasedService(uint timeOut)
 {
     _timeOut = timeOut;
     _currentSecond = 0;
     Update(null);
     _timer = new Timer(Update, null, 1000, 1000);
 }

        public HttpStatusCodeCheckResultProvider(IAgentControlDefinitionProvider agentControlDefinitionProvider, IHttpStatusCodeFetcher httpStatusCodeFetcher)
        {
            if (agentControlDefinitionProvider == null)
            {
                throw new ArgumentNullException("agentControlDefinitionProvider");
            }

            if (httpStatusCodeFetcher == null)
            {
                throw new ArgumentNullException("httpStatusCodeFetcher");
            }

            this.agentControlDefinitionProvider = agentControlDefinitionProvider;
            this.httpStatusCodeFetcher = httpStatusCodeFetcher;

            // get initial check interval
            var agentControlDefinition = this.agentControlDefinitionProvider.GetControlDefinition();
            int checkIntervalInSeconds = DefaultCheckIntervalInSeconds;
            if (agentControlDefinition != null && agentControlDefinition.HttpStatusCodeCheck != null && agentControlDefinition.HttpStatusCodeCheck.CheckIntervalInSeconds > 0)
            {
                checkIntervalInSeconds = agentControlDefinition.HttpStatusCodeCheck.CheckIntervalInSeconds;
            }

            var timerStartTime = new TimeSpan(0, 0, 0);
            var timerInterval = new TimeSpan(0, 0, 0, checkIntervalInSeconds);
            this.timer = new Timer(state => this.UpdateHttpStatusCodeResult(), null, timerStartTime, timerInterval);
        }

        public override void Run()
        {
            Trace.TraceInformation("Worker started processing of messages");

            // Initiates the message pump and callback is invoked for each message that is received, calling close on the client will stop the pump.
            Client.OnMessage((msg) =>
                {
                    Timer renewTimer = new Timer(UpdateLock, msg, 1000, updateLockLeaseInMilliSec); //every 30 seconds after 1 sec
                    try
                    {
                        // Process the message
                        Trace.TraceInformation("Processing Service Bus message: " + msg.SequenceNumber.ToString());
                        string reportReq = (string)msg.Properties["reportReq"];
                            if (!CreateReport(reportReq))
                                msg.DeadLetter();
                        msg.Complete();
                    }
                    catch (Exception e)
                    {
                        // Handle any message processing specific exceptions here
                        Trace.TraceError("Message processing exception: " + e.Message);
                        msg.Abandon();
                    }
                    renewTimer.Dispose();
                });

            CompletedEvent.WaitOne();
        }

        public DiagnosticPipeWriter(string applicationName = null)
        {
            applicationName = applicationName ?? Path.GetFileNameWithoutExtension(Assembly.GetEntryAssembly().Location);
            string dir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "LogPipe", applicationName);

            if (Directory.Exists(dir) == false) Directory.CreateDirectory(dir);

            this.lockContext = new object();
            hooks = new List<IDiagnosticHook>();
            buffer = new AutoFlushingBuffer<LogEvent>(100);
            buffer.IsFlushReEntrant = false;
            buffer.ThrowOnFlushError = false;
            buffer.ErrorOccurred += buffer_ErrorOccurred;
            Action<IEnumerable<LogEvent>> flushAction = new Action<IEnumerable<LogEvent>>((events) =>
            {
                var logPath = Path.Combine(dir, DateTime.UtcNow.Ticks+".js");

                lock (cleanupTimer)
                {
                    File.WriteAllText(logPath,JsonConvert.SerializeObject(events, Formatting.Indented));
                }
            });

            cleanupTimer = new Timer((o) => { CleanupOldLogs(dir); }, null, 1000, 5000);

            buffer.FlushAll = flushAction;
            buffer.StartAutoFlushing(1000);
        }

        static EventProvider()
        {
            Events = Enumerable.Empty<Event>().ToArray();
            Timer = new Timer(ReloadEvents, null, RefreshInterval, RefreshInterval);

            ReloadEvents(null);
        }

 public ClockBasedStateTicker()
 {
     timer = new Timer(state => OnTick(new TickEventArgs()),
         null,
         Timeout.Infinite,
         Period);
 }

        public override void StartToasting()
        {
            if (t_ != null)
                throw new Exception("Already toasting.");

            t_ = new Timer(ServiceTimer, null, 1000, 1000);
        }

 void Application_Start(object sender, EventArgs e)
 {
     StartSuperWebSocketByConfig();
     //StartSuperWebSocketByProgramming();
     var ts = new TimeSpan(0, 0, 0, 0, 5000);
     m_SecureSocketPushTimer = new Timer(OnSecureSocketPushTimerCallback, new object(), ts, ts);
 }

        public override void StartAsync()
        {
            Queue<Document> workItemQueue = new Queue<Document>();
            this.loader.ChargeAsync(workItemQueue, BufferSize);
            Task.Factory.StartNew(() =>
            {
                while (!this.CTS.IsCancellationRequested)
                {
                    while (workItemQueue.Count > 0)
                    {
                        var workitem = workItemQueue.Dequeue();
                        this.processor.ProcessItem(workitem);
                    }
                }
            }, this.CTS.Token);

            this.progressTimer = new Timer((cb) =>
            {
                if (Interlocked.Read(ref printing) == 0)
                {
                    Interlocked.Exchange(ref printing, 1);
                    Console.SetCursorPosition(0, 3);
                    Console.WriteLine(Measurement.ReportProgress());
                    Interlocked.Exchange(ref printing, 0);
                }

            }, null, 500, 500);
        }

 public DatabaseMonitor(int timerPeriod)
 {
     if (timerPeriod > 0)
     {
         _timer = new Timer(new TimerCallback(Timer_Callback), null, 0, timerPeriod);
     }
 }

        public WorkspaceViewModel()
        {
            var dataUnitLocator = ContainerAccessor.Instance.GetContainer().Resolve<IDataUnitLocator>();
            _workspaceDataUnit = dataUnitLocator.ResolveDataUnit<IWorkspaceDataUnit>();
            _crmDataUnit = dataUnitLocator.ResolveDataUnit<ICrmDataUnit>();
            _eventDataUnit = dataUnitLocator.ResolveDataUnit<IEventDataUnit>();

            var time = (int?)ApplicationSettings.Read("LogoutTime");
            _logoutTime = (time.HasValue && time.Value > 0) ? time.Value : 30; // 30 minutes - default logout time

            EventManager.RegisterClassHandler(typeof(Window), UIElement.KeyDownEvent, new RoutedEventHandler(Window_KeyDown));
            EventManager.RegisterClassHandler(typeof(Window), UIElement.MouseDownEvent, new RoutedEventHandler(Window_MouseDown));
            EventManager.RegisterClassHandler(typeof(Window), UIElement.MouseMoveEvent, new RoutedEventHandler(Window_MouseMove));
            EventManager.RegisterClassHandler(typeof(Window), UIElement.MouseWheelEvent, new RoutedEventHandler(Window_MouseWheel));

            _timer = new Timer(LogoutByInactivity, null, 1000 * 60 * _logoutTime, Timeout.Infinite);

            _updateTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(30) };
            _updateTimer.Tick += UpdateTimer_Tick;

            _updateTimer.Start();

            _updateTimerEvents = new DispatcherTimer { Interval = TimeSpan.FromSeconds(30) };
            _updateTimerEvents.Tick += _updateTimerEvents_Tick;

            _updateTimerEvents.Start();
        }