I recently made a fix to a
Silverlight stopwatch class I wrote last
year.
In doing so, I decided to kick it up a notch.
using (new StopwatchPlus("Constructor"))
{
//Debug.WriteLine("Initialized: Ellapsed Ticks: {0}, Ellapsed Milliseconds: {1}", sw.EllapsedTicks, sw.EllapsedMilliseconds); InitializeComponent();
Thread.Sleep(600);
}
Instead of just a simple Stopwatch class, I added functionality to make it easy to
capture timings for blocks of code, output to the Debug Output window, and perform
any custom start/stop action.
StopwatchPlus sp1 = new StopwatchPlus(sw2 =>
Debug.WriteLine("Time! {0}", sw2.EllapsedMilliseconds));
Thread.Sleep(500);
sp1.Stop(); // this will call the stopAction defined in the constructor
In non-debug builds, the StopwatchPlus class does not send output to the debug
window. (I used the ConditionalAttribute … I know I could have used conditional
compilation statements, but I didn’t. :-) ).
using System;
using System.Diagnostics;
namespace WiredPrairie.Silverlight
{
/// <summary> /// StopwatchPlus is used to measure the general performance of Silverlight functionality. Silverlight /// does not provide a high resolution timer as is available in many operating systems, /// so the resolution of this timer is limited to milliseconds. This class is best used to measure /// the relative performance of functions over many iterations. /// </summary> public sealed class StopwatchPlus : IDisposable {
private long _startTick;
private long _elapsed;
private bool _isRunning;
private string _name;
private Action<StopwatchPlus> _startAction;
private Action<StopwatchPlus> _stopAction;
/// <summary> /// Creates an instance of the StopwatchPlus class and starts the timer. By /// providing a value to the name parameter, the Debug Console automatically /// will include the current values when the timer was started and stopped with /// this name. /// </summary> /// <param name="name"></param> public StopwatchPlus(string name)
: this(name, WriteStart, WriteResults) { }
/// <summary> /// Creates an instance of the StopwatchPlus class and starts the timer. /// </summary> /// <param name="stopAction">Action to take when the Stop method is called.</param> public StopwatchPlus(Action<StopwatchPlus> stopAction)
:this(null, stopAction)
{
}
/// <summary> /// Creates an instance of the StopwatchPlus class and starts the timer. /// </summary> /// <param name="startAction">Action to take when the timer starts.</param> /// <param name="stopAction">Action to take when the Stop method is called.</param> public StopwatchPlus(Action<StopwatchPlus> startAction,
Action<StopwatchPlus> stopAction)
:this(null, startAction, stopAction)
{
}
/// <summary> /// Creates an instance of the StopwatchPlus class and starts the timer. /// </summary> /// <param name="name">Name of this stop watch (used as output)</param> /// <param name="startAction">Action to take when the timer starts.</param> /// <param name="stopAction">Action to take when the Stop method is called.</param> public StopwatchPlus(string name,
Action<StopwatchPlus> startAction,
Action<StopwatchPlus> stopAction)
{
_name = name;
_startAction = startAction;
_stopAction = stopAction;
Start();
}
public string Name
{
get { return _name; }
}
/// <summary> /// Completely resets and deactivates the timer. /// </summary> public void Reset()
{
_elapsed = 0;
_isRunning = false;
_startTick = 0;
}
/// <summary> /// Begins the timer. /// </summary> public void Start()
{
if (!_isRunning)
{
_startTick = GetCurrentTicks();
_isRunning = true;
if (_startAction != null)
{
_startAction(this);
}
}
}
/// <summary> /// Stops the current timer. /// </summary> public void Stop()
{
if (_isRunning)
{
_elapsed += GetCurrentTicks() - _startTick;
_isRunning = false;
if (_stopAction != null)
{
_stopAction(this);
}
}
}
/// <summary> /// Gets a value indicating whether the instance is currently recording. /// </summary> public bool IsRunning
{
get { return _isRunning; }
}
/// <summary> /// Gets the Ellapsed time as a Timespan. /// </summary> public TimeSpan Ellapsed
{
get { return TimeSpan.FromMilliseconds(EllapsedMilliseconds); }
}
/// <summary> /// Gets the Ellapsed time as the total number of milliseconds. /// </summary> public long EllapsedMilliseconds
{
get { return GetCurrentElapsedTicks() / TimeSpan.TicksPerMillisecond; }
}
/// <summary> /// Gets the Ellapsed time as the total number of ticks (which is faked /// as Silverlight doesn't have a way to get at the actual "Ticks") /// </summary> public long EllapsedTicks
{
get { return GetCurrentElapsedTicks(); }
}
private long GetCurrentElapsedTicks()
{
return (long)(this._elapsed + (IsRunning ? (GetCurrentTicks() - _startTick) : 0));
}
private long GetCurrentTicks()
{
// TickCount: Gets the number of milliseconds elapsed since the system started. return Environment.TickCount * TimeSpan.TicksPerMillisecond;
}
#region IDisposable Members
public void Dispose()
{
Stop();
}
#endregion private static void WriteStart(StopwatchPlus sw)
{
WriteStartInternal(sw);
}
// This is not called in a Release build [Conditional("DEBUG")]
private static void WriteStartInternal(StopwatchPlus sw)
{
Debug.WriteLine("BEGIN\t{0}", sw._name);
}
private static void WriteResults(StopwatchPlus sw)
{
WriteResultsInternal(sw);
}
// This is not called in a Release build [Conditional("DEBUG")]
private static void WriteResultsInternal(StopwatchPlus sw)
{
Debug.WriteLine("END\t{0}\t{1}", sw._name, sw.EllapsedMilliseconds);
}
}
}
