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 = 1;
            private bool _stoppingTimer;
            public bool IsTimerRunning
            {
                get
                {
                    return this._timerID != 0 && 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 == 0 && !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), 16, 0, 0);
                    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 != 0)
                        {
                            try
                            {
                                this._stoppingTimer = true;
                                SafeNativeMethods.KillTimer(new HandleRef(this, hWnd), this._timerID);
                            }
                            finally
                            {
                                this._timerID = 0;
                                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 == 275)
                {
                    if ((int)((long)m.WParam) == this._timerID)
                    {
                        this._owner.OnTick(EventArgs.Empty);
                        return;
                    }
                }
                else
                {
                    if (m.Msg == 16)
                    {
                        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 = 0;
                    createParams.ExStyle = 0;
                    createParams.ClassStyle = 0;
                    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(100), 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 < 1)
                    {
                        throw new ArgumentOutOfRangeException("Interval", SR.GetString("TimerInvalidInterval", new object[]
                        {
                            value,
                            0.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 = 100;
        }
        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 < 1)
                    {
                        throw new ArgumentOutOfRangeException("Interval", SR.GetString("TimerInvalidInterval", new object[]
                        {
                            value,
                            0.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 = 100;
        }

5、重写了ToString方法

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