A Performance Counters Helper Class

using System;
using System.Collections.Generic;
using System.Diagnostics;

namespace Core
{
    /// <summary>
    /// A base class for performance counters.
    /// </summary>
    public class PerformanceCountersManagerBase : IPerformanceCountersManager
    {
        private bool m_disposed;
        private Dictionary<string, PerformanceCounter> m_performanceCounters = 
            new Dictionary<string, PerformanceCounter>();
        private Dictionary<string, Stopwatch> m_stopwatches = new Dictionary<string, Stopwatch>();
        private Dictionary<string, long> m_counterValues = new Dictionary<string, long>();

        protected Dictionary<string, PerformanceCounter> PerformanceCounters
        {
            get
            {
                return m_performanceCounters;
            }
        }

        /// <summary>
        /// Starts the stopwatch for the given counter.
        /// </summary>
        /// <param name="counterName">Name of the counter.</param>
        public void StartWatch(string counterName)
        {
            if (!m_stopwatches.ContainsKey(counterName))
            {
                m_stopwatches[counterName] = new Stopwatch();
            }

            m_stopwatches[counterName].Reset();
            m_stopwatches[counterName].Start();
        }

        /// <summary>
        /// Stops the stopwatch for the given counter.
        /// </summary>
        /// <param name="counterName">Name of the counter.</param>
        public void StopWatch(string counterName)
        {
            if (!m_stopwatches.ContainsKey(counterName))
            {
                return;
            }
            m_stopwatches[counterName].Stop();
            UpdateCounter(counterName, m_stopwatches[counterName].ElapsedMilliseconds);
        }

        /// <summary>
        /// Updates the performance counter by the given value, if the counter exists.
        /// If the counter does not exist - return
        /// </summary>
        /// <param name="counterName">Name of the counter.</param>
        /// <param name="value">The value.</param>
        public void UpdateCounter(string counterName, long value)
        {
            if (!m_performanceCounters.ContainsKey(counterName)) return;

            m_performanceCounters[counterName].RawValue = value;
        }

        /// <summary>
        /// Increments the specified counter value by 1, if the counter exists.
        /// If the counter does not exist - return
        /// </summary>
        /// <param name="counterName">Name of the counter.</param>
        public void Increment(string counterName)
        {
            if (!m_performanceCounters.ContainsKey(counterName)) return;

            m_performanceCounters[counterName].Increment();
        }

        /// <summary>
        /// Increments the specified counter value by the given value, if the counter exists.
        /// If the counter does not exist - return
        /// </summary>
        /// <param name="counterName">Name of the counter.</param>
        /// <param name="value">The value.</param>
        public void IncrementBy(string counterName, long value)
        {
            if (!m_performanceCounters.ContainsKey(counterName)) return;

            m_performanceCounters[counterName].IncrementBy(value);
        }

        /// <summary>
        /// Gets the elapsed milliseconds of the given counter.
        /// </summary>
        /// <param name="counterName">Name of the counter.</param>
        /// <returns>If stopwatch exists for the counter returns elapsed milliseconds of the counter, 0 otherwise</returns>
        public long GetElapsedMilliseconds(string counterName)
        {
            return !m_stopwatches.ContainsKey(counterName) ? 0 : m_stopwatches[counterName].ElapsedMilliseconds;
        }

        /// <summary>
        /// Resets the counter value to zero.
        /// This does not change the actual performance counter, only its internal representation.
        /// </summary>
        /// <param name="counterName">Name of the counter.</param>
        public void ResetCounterValue(string counterName)
        {
            m_counterValues[counterName] = 0;
        }

        /// <summary>
        /// Increment the counter value by the given value.
        /// This does not change the actual performance counter, only its internal representation.
        /// </summary>
        /// <param name="counterName">Name of the counter.</param>
        /// <param name="value">The value.</param>
        public void IncrementCounterValueBy(string counterName, long value)
        {
            if (!m_counterValues.ContainsKey(counterName))
            {
                return;
            }
            m_counterValues[counterName] += value;
        }

        /// <summary>
        /// Change the value of the counter according to its internal value.
        /// You should use this after calling <see cref="IncrementCounterValueBy"/> when you want to actually
        /// change the counter value.
        /// </summary>
        /// <param name="counterName">Name of the counter.</param>
        public void UpdateCounter(string counterName)
        {
            if (!m_counterValues.ContainsKey(counterName)) return;

            UpdateCounter(counterName, m_counterValues[counterName]);
        }

        protected static PerformanceCounter CreateWritablePerformanceCounter(
            string category, string counterName, string instance)
        {
            return new PerformanceCounter(category, counterName, instance, false) { RawValue = 0 };
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!m_disposed)
            {
                if (disposing)
                {
                    foreach (PerformanceCounter counter in m_performanceCounters.Values)
                    {
                        counter.RemoveInstance();
                        counter.Close();
                        counter.Dispose();
                    }
                }

                m_disposed = true;
            }
        }

        ~PerformanceCountersManagerBase()
        {
            Dispose(false);
        }
    }
}