临时数据。

    internal class RecordingData
    {
        private long m_Ticks;

        public long Ticks
        {
            get { return m_Ticks; }
            internal set
            {
                m_Ticks = value;
                this.HitRate++;
            }
        }

        public int HitRate { get; private set; }

        public RecordingData() : this(0) { }

        public RecordingData(long ticks)
        {
            this.Ticks = ticks;
            this.HitRate = 0;
        }
    }

    public sealed class ExecutionTimer : IDisposable
    {
        internal delegate void ExecutionStopEventHandler(string key, long ticks);

        private string m_ExecutionName;
        private long m_StartTicks;
        private long m_StopTicks;


        internal event ExecutionStopEventHandler StopEvent;

        public long StartTicks
        {
            get { return m_StartTicks; }
        }

        internal ExecutionTimer(string name)
        {
            m_StartTicks = 0;
            m_StopTicks = 0;
            m_ExecutionName = name;
        }

        internal void OnStop()
        {
            if (StopEvent != null)
            {
                StopEvent(m_ExecutionName, m_StopTicks - m_StartTicks);
            }
        }

        public long Start()
        {
            return m_StartTicks = DateTime.Now.Ticks;
        }

        public long Stop()
        {
            if (m_StopTicks > 0)
            {
                return m_StopTicks;
            }

            m_StopTicks = DateTime.Now.Ticks;
            this.OnStop();

            return m_StopTicks;
        }

        #region IDisposable Members
        private bool m_Disposed = false;
        public void Dispose()
        {
            if (m_Disposed)
            {
                return;
            }

            this.Stop();
        }

        #endregion
    }



    public static class ExecutionTimeConsolidated
    {
        private static readonly object s_ThreadLocker = new object();
        private static Dictionary<string, RecordingData> s_DictItemValues;

        static ExecutionTimeConsolidated()
        {
            s_DictItemValues = new Dictionary<string, RecordingData>();
        }

        public static ExecutionTimer ExecutionTimerInstance(string key)
        {
            ExecutionTimer timer = new ExecutionTimer(key);
            timer.StopEvent += new ExecutionTimer.ExecutionStopEventHandler(ExecutionTimer_StopEvent);

            return timer;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="key"></param>
        /// <param name="autoStart">default is false.</param>
        /// <returns></returns>
        public static ExecutionTimer ExecutionTimerInstance(string key, bool autoStart)
        {
            ExecutionTimer timer = ExecutionTimeConsolidated.ExecutionTimerInstance(key);
            if (autoStart)
            {
                timer.Start();
            }

            return timer;
        }

        public static void ClearAll()
        {
            lock (s_ThreadLocker)
            {
                s_DictItemValues.Clear();
            }

            Trace.WriteLine(string.Concat("Clear all at: ", DateTime.Now.ToString("HH:mm:ss ttt")));
        }

        public static void Print()
        {
            Trace.WriteLine(string.Format("==Totals:==({0})=======================", s_DictItemValues.Count));
            foreach (var item in s_DictItemValues)
            {
                Trace.WriteLine(string.Concat(item.Key, ":\t\t", item.Value.Ticks, '(', item.Value.HitRate, ')'));
            }

            Trace.WriteLine(DateTime.Now.ToString("HH:mm:ss ttt"));
            Trace.WriteLine("The end.");
        }


        private static void ExecutionTimer_StopEvent(string key, long ticks)
        {
            lock (s_ThreadLocker)
            {
                if (s_DictItemValues.Keys.Contains(key))
                {
                    s_DictItemValues[key].Ticks += ticks;
                }
                else
                {
                    s_DictItemValues.Add(key, new RecordingData(ticks));
                }
            }
        }
    }