System.Windows.Forms.Timer反编译学习

 using System;
 using System.ComponentModel;
 using System.Globalization;
 using System.Runtime;
 using System.Runtime.InteropServices;
 using System.Threading;
 namespace System.Windows.Forms
 {
     [DefaultEvent("Tick"), DefaultProperty("Interval"), ToolboxItemFilter("System.Windows.Forms"), SRDescription("DescriptionTimer")]
     public class Timer : Component
     {
         private class TimerNativeWindow : NativeWindow
         {
             private Timer _owner;
             private int _timerID;
             private static int TimerID = ;
             private bool _stoppingTimer;
             public bool IsTimerRunning
             {
                 get
                 {
                     return this._timerID !=  && base.Handle != IntPtr.Zero;
                 }
             }
             ~TimerNativeWindow()
             {
                 this.StopTimer();
             }
             public void RestartTimer(int newInterval)
             {
                 this.StopTimer(false, IntPtr.Zero);
                 this.StartTimer(newInterval);
             }
             public void StartTimer(int interval)
             {
                 if (this._timerID ==  && !this._stoppingTimer && this.EnsureHandle())
                 {
                     this._timerID = (int)SafeNativeMethods.SetTimer(new HandleRef(this, base.Handle), Timer.TimerNativeWindow.TimerID++, interval, IntPtr.Zero);
                 }
             }
             public void StopTimer()
             {
                 this.StopTimer(true, IntPtr.Zero);
             }
             public void StopTimer(bool destroyHwnd, IntPtr hWnd)
             {
                 if (hWnd == IntPtr.Zero)
                 {
                     hWnd = base.Handle;
                 }
                 if (this.GetInvokeRequired(hWnd))
                 {
                     UnsafeNativeMethods.PostMessage(new HandleRef(this, hWnd), , , );
                     return;
                 }
                 bool flag = false;
                 try
                 {
                     Monitor.Enter(this, ref flag);
                     if (!this._stoppingTimer && !(hWnd == IntPtr.Zero) && UnsafeNativeMethods.IsWindow(new HandleRef(this, hWnd)))
                     {
                         if (this._timerID != )
                         {
                             try
                             {
                                 this._stoppingTimer = true;
                                 SafeNativeMethods.KillTimer(new HandleRef(this, hWnd), this._timerID);
                             }
                             finally
                             {
                                 this._timerID = ;
                                 this._stoppingTimer = false;
                             }
                         }
                         if (destroyHwnd)
                         {
                             base.DestroyHandle();
                         }
                     }
                 }
                 finally
                 {
                     if (flag)
                     {
                         Monitor.Exit(this);
                     }
                 }
             }
             public override void DestroyHandle()
             {
                 this.StopTimer(false, IntPtr.Zero);
                 base.DestroyHandle();
             }
             protected override void OnThreadException(Exception e)
             {
                 Application.OnThreadException(e);
             }
             public override void ReleaseHandle()
             {
                 this.StopTimer(false, IntPtr.Zero);
                 base.ReleaseHandle();
             }
             protected override void WndProc(ref Message m)
             {
                 if (m.Msg == )
                 {
                     if ((int)((long)m.WParam) == this._timerID)
                     {
                         this._owner.OnTick(EventArgs.Empty);
                         return;
                     }
                 }
                 else
                 {
                     if (m.Msg == )
                     {
                         this.StopTimer(true, m.HWnd);
                         return;
                     }
                 }
                 base.WndProc(ref m);
             }
             internal TimerNativeWindow(Timer owner)
             {
                 this._owner = owner;
             }
             private bool EnsureHandle()
             {
                 if (base.Handle == IntPtr.Zero)
                 {
                     CreateParams createParams = new CreateParams();
                     createParams.Style = ;
                     createParams.ExStyle = ;
                     createParams.ClassStyle = ;
                     createParams.Caption = base.GetType().Name;
                     if (Environment.OSVersion.Platform == PlatformID.Win32NT)
                     {
                         createParams.Parent = (IntPtr)NativeMethods.HWND_MESSAGE;
                     }
                     this.CreateHandle(createParams);
                 }
                 return base.Handle != IntPtr.Zero;
             }
             private bool GetInvokeRequired(IntPtr hWnd)
             {
                 if (hWnd != IntPtr.Zero)
                 {
                     int num;
                     int windowThreadProcessId = SafeNativeMethods.GetWindowThreadProcessId(new HandleRef(this, hWnd), out num);
                     int currentThreadId = SafeNativeMethods.GetCurrentThreadId();
                     return windowThreadProcessId != currentThreadId;
                 }
                 return false;
             }
         }
         private int interval;
         private bool enabled;
         private EventHandler onTimer;
         private GCHandle timerRoot;
         private Timer.TimerNativeWindow timerWindow;
         private object userData;
         private object syncObj = new object();
         [SRCategory("CatBehavior"), SRDescription("TimerTimerDescr")]
         public event EventHandler Tick
         {
             add
             {
                 this.onTimer = (EventHandler)Delegate.Combine(this.onTimer, value);
             }
             remove
             {
                 this.onTimer = (EventHandler)Delegate.Remove(this.onTimer, value);
             }
         }
         [Bindable(true), DefaultValue(null), Localizable(false), TypeConverter(typeof(StringConverter)), SRCategory("CatData"), SRDescription("ControlTagDescr")]
         public object Tag
         {
             [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
             get
             {
                 return this.userData;
             }
             [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
             set
             {
                 this.userData = value;
             }
         }
         [DefaultValue(false), SRCategory("CatBehavior"), SRDescription("TimerEnabledDescr")]
         public virtual bool Enabled
         {
             get
             {
                 if (this.timerWindow == null)
                 {
                     return this.enabled;
                 }
                 return this.timerWindow.IsTimerRunning;
             }
             set
             {
                 lock (this.syncObj)
                 {
                     if (this.enabled != value)
                     {
                         this.enabled = value;
                         if (!base.DesignMode)
                         {
                             if (value)
                             {
                                 if (this.timerWindow == null)
                                 {
                                     this.timerWindow = new Timer.TimerNativeWindow(this);
                                 }
                                 this.timerRoot = GCHandle.Alloc(this);
                                 this.timerWindow.StartTimer(this.interval);
                             }
                             else
                             {
                                 if (this.timerWindow != null)
                                 {
                                     this.timerWindow.StopTimer();
                                 }
                                 if (this.timerRoot.IsAllocated)
                                 {
                                     this.timerRoot.Free();
                                 }
                             }
                         }
                     }
                 }
             }
         }
         [DefaultValue(), SRCategory("CatBehavior"), SRDescription("TimerIntervalDescr")]
         public int Interval
         {
             [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
             get
             {
                 return this.interval;
             }
             set
             {
                 lock (this.syncObj)
                 {
                     if (value < )
                     {
                         throw new ArgumentOutOfRangeException("Interval", SR.GetString("TimerInvalidInterval", new object[]
                         {
                             value,
                             .ToString(CultureInfo.CurrentCulture)
                         }));
                     }
                     if (this.interval != value)
                     {
                         this.interval = value;
                         if (this.Enabled && !base.DesignMode && this.timerWindow != null)
                         {
                             this.timerWindow.RestartTimer(value);
                         }
                     }
                 }
             }
         }
         public Timer()
         {
             this.interval = ;
         }
         public Timer(IContainer container) : this()
         {
             if (container == null)
             {
                 throw new ArgumentNullException("container");
             }
             container.Add(this);
         }
         protected override void Dispose(bool disposing)
         {
             if (disposing)
             {
                 if (this.timerWindow != null)
                 {
                     this.timerWindow.StopTimer();
                 }
                 this.Enabled = false;
             }
             this.timerWindow = null;
             base.Dispose(disposing);
         }
         protected virtual void OnTick(EventArgs e)
         {
             if (this.onTimer != null)
             {
                 this.onTimer(this, e);
             }
         }
         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
         public void Start()
         {
             this.Enabled = true;
         }
         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
         public void Stop()
         {
             this.Enabled = false;
         }
         public override string ToString()
         {
             string str = base.ToString();
             return str + ", Interval: " + this.Interval.ToString(CultureInfo.CurrentCulture);
         }
     }
 }

以上代码是通过ILSpy反编译出来的，学习的心得如下：

1、Start和Stop方法，都是通过设置Enabled属性启用或停用定时器

2、Interval用来设置定时器的运行时间间隔

3、设置Interval注意以下代码：

 public int Interval
         {
             [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
             get
             {
                 return this.interval;
             }
             set
             {
                 lock (this.syncObj)
                 {
                     if (value < )
                     {
                         throw new ArgumentOutOfRangeException("Interval", SR.GetString("TimerInvalidInterval", new object[]
                         {
                             value,
                             .ToString(CultureInfo.CurrentCulture)
                         }));
                     }
                     if (this.interval != value)
                     {
                         this.interval = value;
                         if (this.Enabled && !base.DesignMode && this.timerWindow != null)
                         {
                             this.timerWindow.RestartTimer(value);
                         }
                     }
                 }
             }
         }

4、默认Timter的时间间隔为100毫秒。

 public Timer()
         {
             this.interval = ;
         }

5、重写了ToString方法

 public override string ToString()
         {
             string str = base.ToString();
             return str + ", Interval: " + this.Interval.ToString(CultureInfo.CurrentCulture);
         }