Stopwatch class from .net 2.0 framework ported .net 1.1

/// <summary>Provides a set of methods and properties that you can use to accurately measure elapsed time.</summary>  
public class Stopwatch  
{  
    #region SafeNativeMethods  
    [DllImport("kernel32.dll")]  
    private static extern bool QueryPerformanceFrequency(out long lpFrequency);  
    [DllImport("kernel32.dll")]  
    private static extern bool QueryPerformanceCounter(out long lpPerformanceCount);  
    #endregion //SafeNativeMethods  
    #region Public Fields          
    /// <summary>Gets the frequency of the timer as the number of ticks per second. This field is read-only.</summary>  
    public static readonly long Frequency;  
      
    /// <summary>Indicates whether the timer is based on a high-resolution performance counter. This field is read-only.</summary>  
    public static readonly bool IsHighResolution;  
     
    #endregion //Public Fields  
     
    #region Private Fields  
    private long elapsed;          
    private bool isRunning;  
    private long startTimeStamp;  
      
    private static readonly double tickFrequency;  
    #endregion //Private Fields  
    #region Constructors  
    static Stopwatch()  
    {  
        if (!QueryPerformanceFrequency(out Stopwatch.Frequency))  
        {  
            Stopwatch.IsHighResolution = false;  
            Stopwatch.Frequency = TimeSpan.TicksPerSecond;  
            Stopwatch.tickFrequency = 1;  
        }  
        else  
        {  
            Stopwatch.IsHighResolution = true;  
            Stopwatch.tickFrequency = TimeSpan.TicksPerSecond;  
            Stopwatch.tickFrequency /= ((double)Stopwatch.Frequency);  
        }  
    }  
      
    /// <summary>Initializes a new instance of the Stopwatch class.</summary>  
    public Stopwatch()  
    {  
        this.Reset();  
    }  
    #endregion //Constructors  
     
    #region Private Methods  
    private long GetElapsedDateTimeTicks()  
    {  
        long ticks = this.GetRawElapsedTicks();  
        if (Stopwatch.IsHighResolution)  
        {  
            double highTicks = ticks;  
            highTicks *= Stopwatch.tickFrequency;  
            return (long)highTicks;  
        }  
        return ticks;  
    }  
    private long GetRawElapsedTicks()          
    {  
        long elapsedTimestamp = this.elapsed;  
        if (this.isRunning)  
        {  
            long currentTimestamp = Stopwatch.GetTimestamp();  
            long endTimestamp = currentTimestamp - this.startTimeStamp;  
            elapsedTimestamp += endTimestamp;  
        }  
        return elapsedTimestamp;  
    }  
    #endregion //Private Methods  
    #region Public Methods  
    /// <summary>Gets the current number of ticks in the timer mechanism.</summary>  
    /// <returns>A long integer representing the tick counter value of the underlying timer mechanism.</returns>  
    public static long GetTimestamp()          
    {  
        if (Stopwatch.IsHighResolution)  
        {  
            long ticks = 0;  
            QueryPerformanceCounter(out ticks);  
            return ticks;  
        }  
        return DateTime.UtcNow.Ticks;  
    }  
    /// <summary>Stops time interval measurement and resets the elapsed time to zero.</summary>  
    public void Reset()          
    {  
        this.elapsed = 0;  
        this.isRunning = false;  
        this.startTimeStamp = 0;  
    }  
    /// <summary>Starts, or resumes, measuring elapsed time for an interval.</summary>  
    public void Start()          
    {  
        if (!this.isRunning)  
        {  
            this.startTimeStamp = Stopwatch.GetTimestamp();  
            this.isRunning = true;  
        }  
    }  
    /// <summary>Initializes a new Stopwatch instance, sets the elapsed time property to zero, and starts measuring elapsed time.</summary>  
    /// <returns>A Stopwatch that has just begun measuring elapsed time.</returns>  
    public static Stopwatch StartNew()          
    {  
        Stopwatch stopwatch = new Stopwatch();  
        stopwatch.Start();  
        return stopwatch;  
    }  
    /// <summary>Stops measuring elapsed time for an interval.</summary>  
    public void Stop()          
    {  
        if (this.isRunning)  
        {  
            long currentTimestamp = Stopwatch.GetTimestamp();  
            long endTimestamp = currentTimestamp - this.startTimeStamp;  
            this.elapsed += endTimestamp;  
            this.isRunning = false;  
        }  
    }  
    #endregion //Public Methods  
     
    #region Public Properties  
    /// <summary>Gets the total elapsed time measured by the current instance.</summary>  
    /// <value>A read-only System.TimeSpan representing the total elapsed time measured by the current instance.</value>  
    public TimeSpan Elapsed  
    {  
        get { return new TimeSpan(this.GetElapsedDateTimeTicks()); }  
    }  
      
    /// <summary>Gets the total elapsed time measured by the current instance, in milliseconds.</summary>  
    public long ElapsedMilliseconds  
    {  
        get { return (this.GetElapsedDateTimeTicks() / TimeSpan.TicksPerMillisecond); }  
    }  
    /// <summary>Gets the total elapsed time measured by the current instance, in timer ticks.</summary>  
    public long ElapsedTicks  
    {  
        get { return this.GetRawElapsedTicks(); }  
    }  
      
    /// <summary>Gets a value indicating whether the Stopwatch timer is running.</summary>  
    public bool IsRunning  
    {  
        get { return this.isRunning; }  
    }  
    #endregion //Public Properties  
}