C# Timer.Start方法代码示例

		public override void ViewDidLoad ()
		{
			base.ViewDidLoad ();
			// Perform any additional setup after loading the view, typically from a nib.

			searchField.Text = string.Empty;

			var keyStrokeTimer = new Timer (500);
			var timeElapsedSinceChanged = true;

			keyStrokeTimer.Start ();

			keyStrokeTimer.Elapsed += (sender, e) => {
				timeElapsedSinceChanged = true;
			};

			var searchText = "";
			searchField.EditingChanged += async (sender, e) => {
				keyStrokeTimer.Stop ();

				if (timeElapsedSinceChanged) {
					// Probably should do some locking
					timeElapsedSinceChanged = false;
					keyStrokeTimer.Stop ();

					if (!string.IsNullOrEmpty (searchField.Text)) {
						if (!searchText.Equals (searchField.Text)) {
							searchText = searchField.Text;

							var results = await SearchCheeses (searchText);

							foreach (var cheeseName in results) {
											Console.WriteLine ($"Cheese name: {cheeseName}");
							}
						}
					}
				}

				keyStrokeTimer.Start();
			};


//			var editing = searchField.Events ().EditingChanged;
//
//			var searchSteam = editing
//				.Select (_ => searchField.Text)
//				.Where (t => !string.IsNullOrEmpty (t))
//				.DistinctUntilChanged ()
//				.Throttle (TimeSpan.FromSeconds (0.5))
//				.SelectMany (t =>
//					SearchCheeses (t));			                  
//
//			searchSteam.Subscribe (
//				r =>
//				r.ForEach(cheeseName =>
//					Console.WriteLine($"Cheese name: {cheeseName}"))			
//			);
		}

 public static TimerHandle SetInterval(TimeSpan delay, Action callback)
 {
   var timer = new Timer(delay.TotalMilliseconds);
   timer.Elapsed += (sender, e) =>
     {
       timer.Stop();
       callback();
       timer.Start();
     };
   timer.AutoReset = false;
   timer.Start();
   return new TimerHandle(timer, callback);
 }

        public void Start()
        {
            Database.Initialize(ConnectionString);
            DapperConfig.Initialize();
            DefaultTraceLogInitializer.Initialize(ConnectionString, TraceLogLevel.Trace);
            MarkdownParser.RegisterJsEngineType<V8JsEngine>();

            _logger.Trace(string.Format("WEBJOB Start: Interval = {0} ミリ秒", Interval.ToString("##,###")));

            var service = new SearchService(ConnectionString);
            var status = service.GetServiceStatusAsync().Result;

            if (status == ServiceStatus.IndexNotExists)
            {
                service.RecreateEsIndexAsync().Wait();
            }

            _timer = new Timer
            {
                Interval = Interval
            };

            _timer.Elapsed += Execute;
            _timer.Start();
        }

 protected override void InitializeImpl()
 {
     this._timers = this.TimerJobs
         .Where(j => j.Item1 > 0.0)
         .OrderBy(j => j.Item1)
         .Select(j =>
         {
             Timer timer = new Timer(j.Item1);
             timer.Elapsed += (sender, e) =>
             {
                 timer.Stop();
                 try
                 {
                     this.Host.RequestManager.Execute<Object>(Request.Parse(j.Item2));
                 }
                 finally
                 {
                     timer.Start();
                 }
             };
             return timer;
         }).ToList();
     this.RunInitializingJobs();
     base.InitializeImpl();
 }

 /// <summary>
 /// Initializes a new instance of the App class.
 /// </summary>
 /// <param name="appSplashScreen">Instance of application splash screen window.</param>
 public App(DemoSplashScreen appSplashScreen)
 {
     this.appSplashScreen = appSplashScreen;
     applicationSplashScreenTimer = new ST.Timer(100);
     applicationSplashScreenTimer.Elapsed += new ST.ElapsedEventHandler(applicationSplashScreenTimer_Elapsed);
     applicationSplashScreenTimer.Start();
 }

 public Server()
 {
     config = new INIReader(System.IO.File.ReadAllLines("config.ini"));
     chat = new ServerChat();
     instance = this;
     vehicleController = new ServerVehicleController();
     api = new ServerApi(this);
     gamemodeManager = new GamemodeManager(api);
     gamemodeManager.loadFromFile("gamemodes/" + config.getString("gamemode"));
     server = new TcpListener(IPAddress.Any, config.getInt("game_port"));
     server.Start();
     server.BeginAcceptTcpClient(onIncomingConnection, null);
     playerpool = new List<ServerPlayer>();
     Timer timer = new Timer();
     timer.Elapsed += onBroadcastTimer;
     timer.Interval = config.getInt("broadcast_interval");
     timer.Enabled = true;
     timer.Start();
     UDPStartPort = config.getInt("udp_start_port");
     Timer timer_slow = new Timer();
     timer_slow.Elapsed += timer_slow_Elapsed;
     timer_slow.Interval = config.getInt("slow_interval");
     timer_slow.Enabled = true;
     timer_slow.Start();
     http_server = new HTTPServer();
     Console.WriteLine("Started game server on port " + config.getInt("game_port").ToString());
     Console.WriteLine("Started http server on port " + config.getInt("http_port").ToString());
 }

 public SamplingTargetPointGenerator(int samplesPerSecond)
 {
     workerTimer = new Timer(1000 / samplesPerSecond);
     workerTimer.Elapsed += this.WorkerTimerElapsed;
     workerTimer.AutoReset = false;
     workerTimer.Start();
 }

    /// <summary>
    /// Constructor
    /// </summary>
    public CreateJoinForm(Peer peerObject, Address addressObject, ConnectWizard connectionWizard)
    {
        //
        // Required for Windows Form Designer support
        //
        InitializeComponent();
        peer = peerObject;
        this.connectionWizard = connectionWizard;
        this.Text = connectionWizard.SampleName + " - " + this.Text;
        deviceAddress = addressObject;

        //Set up the event handlers
        peer.FindHostResponse += new FindHostResponseEventHandler(FindHostResponseMessage);
        peer.ConnectComplete += new ConnectCompleteEventHandler(ConnectResult);
        peer.AsyncOperationComplete += new AsyncOperationCompleteEventHandler(CancelAsync);

        //Set up our timer
        updateListTimer = new System.Timers.Timer(300); // A 300 ms interval
        updateListTimer.Elapsed += new System.Timers.ElapsedEventHandler(this.UpdateTimer);
        updateListTimer.SynchronizingObject = this;
        updateListTimer.Start();
        //Set up our connect timer
        connectTimer = new System.Timers.Timer(100); // A 100ms interval
        connectTimer.Elapsed += new System.Timers.ElapsedEventHandler(this.ConnectTimer);
        connectTimer.SynchronizingObject = this;
        // Set up our connect event
        connectEvent = new ManualResetEvent(false);
    }

        /// <summary>
        /// Create an new Instance of the TCP-Listener on Port 5000
        /// </summary>
        internal Server()
        {
            try
            {
                AnrlDB.AnrlDataContext db = new AnrlDB.AnrlDataContext();
                if (!db.DatabaseExists())
                {
                    db.CreateDatabase();
                }

                CalculateTabels = new System.Timers.Timer(20000);
                CalculateTabels.Elapsed += new ElapsedEventHandler(CalculateTabels_Elapsed);
                CalculateTabels.Start();

                running = true;
                this.tcpListener = new TcpListener(IPAddress.Any, 5000);
                this.listenThread = new Thread(new ThreadStart(ListenForClients));
                this.listenThread.Start();
                db.Dispose();
            }
            catch (Exception ex)
            {
                Logger.Log("Exception in Server.Server" + ex.ToString(), 11);
            }
        }

 public void Start()
 {
     _t = new Timer();
     _t.Elapsed += Ticked;
     _t.Interval = 1000;
     _t.Start();
 }

        public AbsoluteTimerWaitHandle(DateTimeOffset dueTime)
        {
            _dueTime = dueTime;
            _eventWaitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);

            SafeWaitHandle = _eventWaitHandle.SafeWaitHandle;

            var dueSpan = (_dueTime - DateTimeOffset.Now);
            var period = new TimeSpan(dueSpan.Ticks / 10);

            if (dueSpan < TimeSpan.Zero)
            {
                _eventWaitHandle.Set();
            }
            else
            {
                _timer = new Timer(period.TotalMilliseconds)
                {
                    AutoReset = false,
                };

                _timer.Elapsed += TimerOnElapsed;

                _timer.Start();
            }
        }

        /// <summary>
        /// Basic run through, timer setup for read and data save from G4
        /// </summary>
        /// <param name="options">Parsed command line parameters</param>
        private static void Run(Options options)
        {
            if (!string.IsNullOrEmpty(options.Time))
            {
                HeadingInfo.WriteMessage(string.Format("G4 will be polled every {0} milliseconds", options.Time));
            }

            if (!string.IsNullOrEmpty(options.OutputFile))
            {
                HeadingInfo.WriteMessage(string.Format("Writing G4 data to: {0}", options.OutputFile));
            }
            else
            {
                HeadingInfo.WriteMessage("G4 data could not be written.");
                Console.WriteLine("[...]");
            }

            Timer myTimer = new Timer();
            myTimer.Elapsed += new ElapsedEventHandler((sender, e) => ReadAndSaveEGV(sender, e, options));
            myTimer.Interval = Int32.Parse(options.Time);
            myTimer.Start();

            while (Console.Read() != 'q')
            {
                ;    // do nothing...
            }
        }

        public Game(string mapPath)
        {
            totalPoints = 0;

            totalRounds = 9; //TU ILE MAP MA GRA TRZEBA WPISAC

            typewriter = Constants.getSoundPlayerInstance();
            typewriter.Stop();
            typewriter.SoundLocation = "step.wav";

            isNewLevel = true;

            currentPositionInPauseMenu = 0;

            timerPauseMenu = new Timer(500);
            timerPauseMenu.AutoReset = true;
            timerPauseMenu.Elapsed += (s, e) => pasueMenuTick(e);
            timerPauseMenu.Start();

            heroObject = new Hero();
            boxObject = new Box();
            pointObject = new Point();
            floorObject = new Floor();
            wallObject = new Wall();

            mapNumber = 1;
            writelock = new object();
            initMap(mapPath, true);
        }

 public CacheUpdater()
 {
     updater = new Timer(5000);
     updater.AutoReset = true;
     updater.Elapsed += updater_Elapsed;
     updater.Start();
 }

 public VisualTimer(double time)
 {
     Interval = TimeLeft = time;
     _checker = new Timer(100);
     _checker.Elapsed += CheckerElapsed;
     _checker.Start();
 }