概述
概述(来自MSDN)
Timer 组件是基于服务器的计时器，它使您能够指定在应用程序中引发 Elapsed 事件的周期性间隔。然后可以操控此事件以提供定期处理。例如，假设您有一台关键性服务器，必须每周 7 天、每天 24 小时都保持运行。可以创建一个使用 Timer 的服务，以定期检查服务器并确保系统开启并在运行。如果系统不响应，则该服务可以尝试重新启动服务器或通知管理员。
基于服务器的 Timer 是为在多线程环境中用于辅助线程而设计的。服务器计时器可以在线程间移动来处理引发的 Elapsed 事件，这样就可以比 Windows 计时器更精确地按时引发事件。
基于 Interval 属性的值，Timer 组件引发 Elapsed 事件。可以处理该事件以执行所需的处理。例如，假设您有一个联机销售应用程序，它不断向数据库发送销售订单。编译发货指令的服务分批处理订单，而不是分别处理每个订单。可以使用 Timer 每 30 分钟启动一次批处理。
注意
当 AutoReset设置为false时，Timer只在第一个Interval过后引发一次Elapsed事件。若要保持以Interval时间间隔引发 Elapsed 事件，请将AutoReset设置为true。
Elapsed事件在ThreadPool线程上引发。如果Elapsed事件的处理时间比Interval长，在另一个hreadPool线程上将会再次引发此事件。因此，事件处理程序应当是可重入的。
注意
在一个线程调用 Stop 方法或将 Enabled 属性设置为 false 的同时，可在另一个线程上运行事件处理方法。这可能导致在计时器停止之后引发 Elapsed 事件。Stop 方法的示例代码演示了一种避免此争用条件的方法。
如果和用户界面元素（如窗体或控件）一起使用 Timer，请将包含有 Timer 的窗体或控件赋值给SynchronizingObject 属性，以便将此事件封送到用户界面线程中。 Timer 在运行时是不可见的。
几点说明
private System.Timers.Timer _TestTimerEvent= new Timer(); 1、默认的周期是0.1秒执行一次；
2、AutoReset的初始值为true.
3、它的timer机制和System.Threading.Timer 原理是一样的。
4、每次周期(Timer)运行一次会新起一个线程。
5、如果Elapsed事件的处理时间比Interval长，它每个周期执行都会新起一个线程，这个线程的执行时间不受interval的限定，可以比interval长，因为一个新周期执行，又会新起一个线程，Timer起的线程周期就是事件处理时间。
我们来看它的实现代码.（.net framework 提供的）.
//------------------------------------------------------------------------------
// <copyright file="Timer.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------------
namespace System.Timers {
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using System.ComponentModel;
using System.ComponentModel.Design;
using System;
using Microsoft.Win32;
using Microsoft.Win32.SafeHandles;
/// <devdoc>
/// <para>Handles recurring events in an application.</para>
/// </devdoc>
[
DefaultProperty("Interval"),
DefaultEvent("Elapsed"),
HostProtection(Synchronization=true, ExternalThreading=true)
]
public class Timer : Component, ISupportInitialize {
private double interval;
private bool enabled;
private bool initializing;
private bool delayedEnable;
private ElapsedEventHandler onIntervalElapsed;
private bool autoReset;
private ISynchronizeInvoke synchronizingObject;
private bool disposed;
private System.Threading.Timer timer;
private TimerCallback callback;
private Object cookie;
/// <devdoc>
/// <para>Initializes a new instance of the <see cref='System.Timers.Timer'/> class, with the properties
/// set to initial values.</para>
/// </devdoc>
public Timer()
: base() {
interval = 100;
enabled = false;
autoReset = true;
initializing = false;
delayedEnable = false;
callback = new TimerCallback(this.MyTimerCallback);
}
/// <devdoc>
/// <para>
/// Initializes a new instance of the <see cref='System.Timers.Timer'/> class, setting the <see cref='System.Timers.Timer.Interval'/> property to the specified period.
/// </para>
/// </devdoc>
public Timer(double interval)
: this() {
if (interval <= 0)
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "interval", interval));
int i = (int)Math.Ceiling(interval);
if( i < 0) {
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "interval", interval));
}
this.interval = interval;
}
/// <devdoc>
/// <para>Gets or sets a value indicating whether the Timer raises the Tick event each time the specified
/// Interval has elapsed,
/// when Enabled is set to true.</para>
/// </devdoc>
[Category("Behavior"), TimersDescription(SR.TimerAutoReset), DefaultValue(true)]
public bool AutoReset {
get {
return this.autoReset;
}
set {
if (DesignMode)
this.autoReset = value;
else if (this.autoReset != value) {
this.autoReset = value;
if( timer != null) {
UpdateTimer();
}
}
}
}
/// <devdoc>
/// <para>Gets or sets a value indicating whether the <see cref='System.Timers.Timer'/>
/// is able
/// to raise events at a defined interval.</para>
/// </devdoc>
//[....] - The default value by design is false, don't change it.
[Category("Behavior"), TimersDescription(SR.TimerEnabled), DefaultValue(false)]
public bool Enabled {
get {
return this.enabled;
}
set {
if (DesignMode) {
this.delayedEnable = value;
this.enabled = value;
}
else if (initializing)
this.delayedEnable = value;
else if (enabled != value) {
if (!value) {
if( timer != null) {
cookie = null;
timer.Dispose();
timer = null;
}
enabled = value;
}
else {
enabled = value;
if( timer == null) {
if (disposed) {
throw new ObjectDisposedException(GetType().Name);
}
int i = (int)Math.Ceiling(interval);
cookie = new Object();
timer = new System.Threading.Timer(callback, cookie, i, autoReset? i:Timeout.Infinite);
}
else {
UpdateTimer();
}
}
}
}
}
private void UpdateTimer() {
int i = (int)Math.Ceiling(interval);
timer.Change(i, autoReset? i :Timeout.Infinite );
}
/// <devdoc>
/// <para>Gets or
/// sets the interval on which
/// to raise events.</para>
/// </devdoc>
[Category("Behavior"), TimersDescription(SR.TimerInterval), DefaultValue(100d), RecommendedAsConfigurable(true)]
public double Interval {
get {
return this.interval;
}
set {
if (value <= 0)
throw new ArgumentException(SR.GetString(SR.TimerInvalidInterval, value, 0));
interval = value;
if (timer != null) {
UpdateTimer();
}
}
}
/// <devdoc>
/// <para>Occurs when the <see cref='System.Timers.Timer.Interval'/> has
/// elapsed.</para>
/// </devdoc>
[Category("Behavior"), TimersDescription(SR.TimerIntervalElapsed)]
public event ElapsedEventHandler Elapsed {
add {
onIntervalElapsed += value;
}
remove {
onIntervalElapsed -= value;
}
}
/// <devdoc>
/// <para>
/// Sets the enable property in design mode to true by default.
/// </para>
/// </devdoc>
/// <internalonly/>
public override ISite Site {
set {
base.Site = value;
if (this.DesignMode)
this.enabled= true;
}
get {
return base.Site;
}
}
/// <devdoc>
/// <para>Gets or sets the object used to marshal event-handler calls that are issued when
/// an interval has elapsed.</para>
/// </devdoc>
[
Browsable(false),
DefaultValue(null),
TimersDescription(SR.TimerSynchronizingObject)
]
public ISynchronizeInvoke SynchronizingObject {
get {
if (this.synchronizingObject == null && DesignMode) {
IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));
if (host != null) {
object baseComponent = host.RootComponent;
if (baseComponent != null && baseComponent is ISynchronizeInvoke)
this.synchronizingObject = (ISynchronizeInvoke)baseComponent;
}
}
return this.synchronizingObject;
}
set {
this.synchronizingObject = value;
}
}
/// <devdoc>
/// <para>
/// Notifies
/// the object that initialization is beginning and tells it to stand by.
/// </para>
/// </devdoc>
public void BeginInit() {
this.Close();
this.initializing = true;
}
/// <devdoc>
/// <para>Disposes of the resources (other than memory) used by
/// the <see cref='System.Timers.Timer'/>.</para>
/// </devdoc>
public void Close() {
initializing = false;
delayedEnable = false;
enabled = false;
if (timer != null ) {
timer.Dispose();
timer = null;
}
}
/// <internalonly/>
/// <devdoc>
/// </devdoc>
protected override void Dispose(bool disposing) {
Close();
this.disposed = true;
base.Dispose(disposing);
}
/// <devdoc>
/// <para>
/// Notifies the object that initialization is complete.
/// </para>
/// </devdoc>
public void EndInit() {
this.initializing = false;
this.Enabled = this.delayedEnable;
}
/// <devdoc>
/// <para>Starts the timing by setting <see cref='System.Timers.Timer.Enabled'/> to <see langword='true'/>.</para>
/// </devdoc>
public void Start() {
Enabled = true;
}
/// <devdoc>
/// <para>
/// Stops the timing by setting <see cref='System.Timers.Timer.Enabled'/> to <see langword='false'/>.
/// </para>
/// </devdoc>
public void Stop() {
Enabled = false;
}
private void MyTimerCallback(object state) {
// System.Threading.Timer will not cancel the work item queued before the timer is stopped.
// We don't want to handle the callback after a timer is stopped.
if( state != cookie) {
return;
}
if (!this.autoReset) {
enabled = false;
}
FILE_TIME filetime = new FILE_TIME();
GetSystemTimeAsFileTime(ref filetime);
ElapsedEventArgs elapsedEventArgs = new ElapsedEventArgs(filetime.ftTimeLow, filetime.ftTimeHigh);
try {
// To avoid ---- between remove handler and raising the event
ElapsedEventHandler intervalElapsed = this.onIntervalElapsed;
if (intervalElapsed != null) {
if (this.SynchronizingObject != null && this.SynchronizingObject.InvokeRequired)
this.SynchronizingObject.BeginInvoke(intervalElapsed, new object[]{this, elapsedEventArgs});
else
intervalElapsed(this, elapsedEventArgs);
}
}
catch {
}
}
[StructLayout(LayoutKind.Sequential)]
internal struct FILE_TIME {
internal int ftTimeLow;
internal int ftTimeHigh;
}
[DllImport(ExternDll.Kernel32), SuppressUnmanagedCodeSecurityAttribute()]
internal static extern void GetSystemTimeAsFileTime(ref FILE_TIME lpSystemTimeAsFileTime);
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
在初始化的时候它的代码实现是这样的.
public Timer()
: base() {
interval = 100;
enabled = false;
autoReset = true;
initializing = false;
delayedEnable = false;
callback = new TimerCallback(this.MyTimerCallback);
}
而如果你是这样的话
public Timer(double interval)
: this() {
if (interval <= 0)
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "interval", interval));
int i = (int)Math.Ceiling(interval);
if( i < 0) {
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "interval", interval));
}
this.interval = interval;
}
你就需要再设置下AutoReset = True;
我们加载事件的Elapsed的代码实现是这样的.
/// <devdoc>
/// <para>Occurs when the <see cref='System.Timers.Timer.Interval'/> has
/// elapsed.</para>
/// </devdoc>
[Category("Behavior"), TimersDescription(SR.TimerIntervalElapsed)]
public event ElapsedEventHandler Elapsed {
add {
onIntervalElapsed += value;
}
remove {
onIntervalElapsed -= value;
}
}
对它的基本原理有一定了解后，我们开始写一个简单的实现程序。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using Timer = System.Timers.Timer;
using System.Timers;
namespace TestMultipleThread
{
public class ThreadWork
{
private System.Timers.Timer _TestTimerEvent;
public void StartWork()
{
_TestTimerEvent = new Timer();
_TestTimerEvent.Elapsed += Sum;
_TestTimerEvent.Start();
}
public static object lockobject = new object();
private void Sum(object sender, ElapsedEventArgs e)
{
Console.WriteLine(string.Format("this is thread ID {0} execute", Thread.CurrentThread.ManagedThreadId));
for (int i = 0; i < 10000; i++)
{
Thread.Sleep(10);
}
}
}
class Program
{
public static void Main()
{
ThreadWork threadWork = new ThreadWork();
ThreadStart myThreadDelegate = new ThreadStart(threadWork.StartWork);
Thread myThread = new Thread(myThreadDelegate);
myThread.Start();
Thread.Sleep(1000000);
}
}
}
查看的运行结果是:
我们看下执行的线程数有多少
能说明的一个问题就是在timer每次执行时都会新起一个线程来执行。
作者：spring yang
出处：http://www.cnblogs.com/springyangwc/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
最后
以上就是忐忑指甲油为你收集整理的.NET System.Timers.Timer的原理和使用(开发定时执行程序)的全部内容，希望文章能够帮你解决.NET System.Timers.Timer的原理和使用(开发定时执行程序)所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复