Stopwatch.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Services / Monitoring / system / Diagnosticts / Stopwatch.cs / 1305376 / Stopwatch.cs

                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
/*============================================================
** 
** Class:  Stopwatch 
**
** Purpose: Implementation for Stopwatch class. 
**
** Date:  Nov 27, 2002
**
===========================================================*/ 

namespace System.Diagnostics 
{ 
    using Microsoft.Win32;
    using System; 

    // This class uses high-resolution performance counter if installed hardware
    // does not support it. Otherwise, the class will fall back to DateTime class
    // and uses ticks as a measurement. 

    public class Stopwatch { 
        private const long TicksPerMillisecond = 10000; 
        private const long TicksPerSecond = TicksPerMillisecond * 1000;
 
        private long elapsed;
        private long startTimeStamp;
        private bool isRunning;
 
        // "Frequency" stores the frequency of the high-resolution performance counter,
        // if one exists. Otherwise it will store TicksPerSecond. 
        // The frequency cannot change while the system is running, 
        // so we only need to initialize it once.
        public static readonly long Frequency; 
        public static readonly bool IsHighResolution;

        // performance-counter frequency, in counts per ticks.
        // This can speed up conversion from high frequency performance-counter 
        // to ticks.
        private static readonly double tickFrequency; 
 
        static Stopwatch() {
            bool succeeded = SafeNativeMethods.QueryPerformanceFrequency(out Frequency); 
            if(!succeeded) {
                IsHighResolution = false;
                Frequency = TicksPerSecond;
                tickFrequency = 1; 
            }
            else { 
                IsHighResolution = true; 
                tickFrequency = TicksPerSecond;
                tickFrequency /= Frequency; 
            }
        }

        public Stopwatch() { 
            Reset();
        } 
 
        public void Start() {
            // Calling start on a running Stopwatch is a no-op. 
            if(!isRunning) {
                startTimeStamp = GetTimestamp();
                isRunning = true;
            } 
        }
 
        public static Stopwatch StartNew() { 
            Stopwatch s = new Stopwatch();
            s.Start(); 
            return s;
        }

        public void Stop() { 
            // Calling stop on a stopped Stopwatch is a no-op.
            if( isRunning) { 
                long endTimeStamp = GetTimestamp(); 
                long elapsedThisPeriod = endTimeStamp - startTimeStamp;
                elapsed += elapsedThisPeriod; 
                isRunning = false;

                if (elapsed < 0) {
                    // When measuring small time periods the StopWatch.Elapsed* 
                    // properties can return negative values.  This is due to
                    // bugs in the basic input/output system (BIOS) or the hardware 
                    // abstraction layer (HAL) on machines with variable-speed CPUs 
                    // (e.g. Intel SpeedStep).
 
                    elapsed = 0;
                }
            }
        } 

        public void Reset() { 
            elapsed = 0; 
            isRunning = false;
            startTimeStamp = 0; 
        }

        // Convenience method for replacing {sw.Reset(); sw.Start();} with a single sw.Restart()
        public void Restart() { 
            elapsed = 0;
            startTimeStamp = GetTimestamp(); 
            isRunning = true; 
        }
 
        public bool IsRunning {
            get { return isRunning; }
        }
 
        public TimeSpan Elapsed {
            get { return new TimeSpan( GetElapsedDateTimeTicks()); } 
        } 

        public long ElapsedMilliseconds { 
            get { return GetElapsedDateTimeTicks()/TicksPerMillisecond; }
        }

        public long ElapsedTicks { 
            get { return GetRawElapsedTicks(); }
        } 
 
        public static long GetTimestamp() {
            if(IsHighResolution) { 
                long timestamp = 0;
                SafeNativeMethods.QueryPerformanceCounter(out timestamp);
                return timestamp;
            } 
            else {
                return DateTime.UtcNow.Ticks; 
            } 
        }
 
        // Get the elapsed ticks.
        private long GetRawElapsedTicks() {
            long timeElapsed = elapsed;
 
            if( isRunning) {
                // If the StopWatch is running, add elapsed time since 
                // the Stopwatch is started last time. 
                long currentTimeStamp = GetTimestamp();
                long elapsedUntilNow = currentTimeStamp - startTimeStamp; 
                timeElapsed += elapsedUntilNow;
            }
            return timeElapsed;
        } 

        // Get the elapsed ticks. 
        private long GetElapsedDateTimeTicks() { 
            long rawTicks = GetRawElapsedTicks();
            if( IsHighResolution) { 
                // convert high resolution perf counter to DateTime ticks
                double dticks = rawTicks;
                dticks *= tickFrequency;
                return unchecked((long)dticks); 
            }
            else { 
                return rawTicks; 
            }
        } 

    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK