1 using System;  2 using System.ComponentModel;  3 using System.Globalization;  4 using System.Runtime;  5 using System.Runtime.InteropServices;  6 using System.Threading;  7 namespace System.Windows.Forms  8 {  9     [DefaultEvent("Tick"), DefaultProperty("Interval"), ToolboxItemFilter("System.Windows.Forms"), SRDescription("DescriptionTimer")] 10     public class Timer : Component 11     { 12         private class TimerNativeWindow : NativeWindow 13         { 14             private Timer _owner; 15             private int _timerID; 16             private static int TimerID = 1; 17             private bool _stoppingTimer; 18             public bool IsTimerRunning 19             { 20                 get 21                 { 22                     return this._timerID != 0 && base.Handle != IntPtr.Zero; 23                 } 24             } 25             ~TimerNativeWindow() 26             { 27                 this.StopTimer(); 28             } 29             public void RestartTimer(int newInterval) 30             { 31                 this.StopTimer(false, IntPtr.Zero); 32                 this.StartTimer(newInterval); 33             } 34             public void StartTimer(int interval) 35             { 36                 if (this._timerID == 0 && !this._stoppingTimer && this.EnsureHandle()) 37                 { 38                     this._timerID = (int)SafeNativeMethods.SetTimer(new HandleRef(this, base.Handle), Timer.TimerNativeWindow.TimerID++, interval, IntPtr.Zero); 39                 } 40             } 41             public void StopTimer() 42             { 43                 this.StopTimer(true, IntPtr.Zero); 44             } 45             public void StopTimer(bool destroyHwnd, IntPtr hWnd) 46             { 47                 if (hWnd == IntPtr.Zero) 48                 { 49                     hWnd = base.Handle; 50                 } 51                 if (this.GetInvokeRequired(hWnd)) 52                 { 53                     UnsafeNativeMethods.PostMessage(new HandleRef(this, hWnd), 16, 0, 0); 54                     return; 55                 } 56                 bool flag = false; 57                 try 58                 { 59                     Monitor.Enter(this, ref flag); 60                     if (!this._stoppingTimer && !(hWnd == IntPtr.Zero) && UnsafeNativeMethods.IsWindow(new HandleRef(this, hWnd))) 61                     { 62                         if (this._timerID != 0) 63                         { 64                             try 65                             { 66                                 this._stoppingTimer = true; 67                                 SafeNativeMethods.KillTimer(new HandleRef(this, hWnd), this._timerID); 68                             } 69                             finally 70                             { 71                                 this._timerID = 0; 72                                 this._stoppingTimer = false; 73                             } 74                         } 75                         if (destroyHwnd) 76                         { 77                             base.DestroyHandle(); 78                         } 79                     } 80                 } 81                 finally 82                 { 83                     if (flag) 84                     { 85                         Monitor.Exit(this); 86                     } 87                 } 88             } 89             public override void DestroyHandle() 90             { 91                 this.StopTimer(false, IntPtr.Zero); 92                 base.DestroyHandle(); 93             } 94             protected override void OnThreadException(Exception e) 95             { 96                 Application.OnThreadException(e); 97             } 98             public override void ReleaseHandle() 99             {100                 this.StopTimer(false, IntPtr.Zero);101                 base.ReleaseHandle();102             }103             protected override void WndProc(ref Message m)104             {105                 if (m.Msg == 275)106                 {107                     if ((int)((long)m.WParam) == this._timerID)108                     {109                         this._owner.OnTick(EventArgs.Empty);110                         return;111                     }112                 }113                 else114                 {115                     if (m.Msg == 16)116                     {117                         this.StopTimer(true, m.HWnd);118                         return;119                     }120                 }121                 base.WndProc(ref m);122             }123             internal TimerNativeWindow(Timer owner)124             {125                 this._owner = owner;126             }127             private bool EnsureHandle()128             {129                 if (base.Handle == IntPtr.Zero)130                 {131                     CreateParams createParams = new CreateParams();132                     createParams.Style = 0;133                     createParams.ExStyle = 0;134                     createParams.ClassStyle = 0;135                     createParams.Caption = base.GetType().Name;136                     if (Environment.OSVersion.Platform == PlatformID.Win32NT)137                     {138                         createParams.Parent = (IntPtr)NativeMethods.HWND_MESSAGE;139                     }140                     this.CreateHandle(createParams);141                 }142                 return base.Handle != IntPtr.Zero;143             }144             private bool GetInvokeRequired(IntPtr hWnd)145             {146                 if (hWnd != IntPtr.Zero)147                 {148                     int num;149                     int windowThreadProcessId = SafeNativeMethods.GetWindowThreadProcessId(new HandleRef(this, hWnd), out num);150                     int currentThreadId = SafeNativeMethods.GetCurrentThreadId();151                     return windowThreadProcessId != currentThreadId;152                 }153                 return false;154             }155         }156         private int interval;157         private bool enabled;158         private EventHandler onTimer;159         private GCHandle timerRoot;160         private Timer.TimerNativeWindow timerWindow;161         private object userData;162         private object syncObj = new object();163         [SRCategory("CatBehavior"), SRDescription("TimerTimerDescr")]164         public event EventHandler Tick165         {166             add167             {168                 this.onTimer = (EventHandler)Delegate.Combine(this.onTimer, value);169             }170             remove171             {172                 this.onTimer = (EventHandler)Delegate.Remove(this.onTimer, value);173             }174         }175         [Bindable(true), DefaultValue(null), Localizable(false), TypeConverter(typeof(StringConverter)), SRCategory("CatData"), SRDescription("ControlTagDescr")]176         public object Tag177         {178             [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]179             get180             {181                 return this.userData;182             }183             [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]184             set185             {186                 this.userData =http://www.mamicode.com/ value;187             }188         }189         [DefaultValue(false), SRCategory("CatBehavior"), SRDescription("TimerEnabledDescr")]190         public virtual bool Enabled191         {192             get193             {194                 if (this.timerWindow == null)195                 {196                     return this.enabled;197                 }198                 return this.timerWindow.IsTimerRunning;199             }200             set201             {202                 lock (this.syncObj)203                 {204                     if (this.enabled != value)205                     {206                         this.enabled = value;207                         if (!base.DesignMode)208                         {209                             if (value)210                             {211                                 if (this.timerWindow == null)212                                 {213                                     this.timerWindow = new Timer.TimerNativeWindow(this);214                                 }215                                 this.timerRoot = GCHandle.Alloc(this);216                                 this.timerWindow.StartTimer(this.interval);217                             }218                             else219                             {220                                 if (this.timerWindow != null)221                                 {222                                     this.timerWindow.StopTimer();223                                 }224                                 if (this.timerRoot.IsAllocated)225                                 {226                                     this.timerRoot.Free();227                                 }228                             }229                         }230                     }231                 }232             }233         }234         [DefaultValue(100), SRCategory("CatBehavior"), SRDescription("TimerIntervalDescr")]235         public int Interval236         {237             [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]238             get239             {240                 return this.interval;241             }242             set243             {244                 lock (this.syncObj)245                 {246                     if (value < 1)247                     {248                         throw new ArgumentOutOfRangeException("Interval", SR.GetString("TimerInvalidInterval", new object[]249                         {250                             value,251                             0.ToString(CultureInfo.CurrentCulture)252                         }));253                     }254                     if (this.interval != value)255                     {256                         this.interval = value;257                         if (this.Enabled && !base.DesignMode && this.timerWindow != null)258                         {259                             this.timerWindow.RestartTimer(value);260                         }261                     }262                 }263             }264         }265         public Timer()266         {267             this.interval = 100;268         }269         public Timer(IContainer container) : this()270         {271             if (container == null)272             {273                 throw new ArgumentNullException("container");274             }275             container.Add(this);276         }277         protected override void Dispose(bool disposing)278         {279             if (disposing)280             {281                 if (this.timerWindow != null)282                 {283                     this.timerWindow.StopTimer();284                 }285                 this.Enabled = false;286             }287             this.timerWindow = null;288             base.Dispose(disposing);289         }290         protected virtual void OnTick(EventArgs e)291         {292             if (this.onTimer != null)293             {294                 this.onTimer(this, e);295             }296         }297         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]298         public void Start()299         {300             this.Enabled = true;301         }302         [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]303         public void Stop()304         {305             this.Enabled = false;306         }307         public override string ToString()308         {309             string str = base.ToString();310             return str + ", Interval: " + this.Interval.ToString(CultureInfo.CurrentCulture);311         }312     }313 }

 1 public int Interval 2         { 3             [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] 4             get 5             { 6                 return this.interval; 7             } 8             set 9             {10                 lock (this.syncObj)11                 {12                     if (value < 1)13                     {14                         throw new ArgumentOutOfRangeException("Interval", SR.GetString("TimerInvalidInterval", new object[]15                         {16                             value,17                             0.ToString(CultureInfo.CurrentCulture)18                         }));19                     }20                     if (this.interval != value)21                     {22                         this.interval = value;23                         if (this.Enabled && !base.DesignMode && this.timerWindow != null)24                         {25                             this.timerWindow.RestartTimer(value);26                         }27                     }28                 }29             }30         }

1 public Timer()2         {3             this.interval = 100;4         }

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