spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

using System;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.Threading;

namespace BloodlineSharp
{
    /// <summary>

    /// Klasse für genaue Zeitmessungen.

    /// </summary>

    /// <remarks>

    /// Verwendet Win32 Performance Counter

    /// </remarks>

    public class Timer
    {
        //--------------------------------------------

        #region Variables
        //--------------------------------------------


        private long _startTime;
        private double _duration;
        private long _stopTime;
        private long _freq;

        //--------------------------------------------

        #endregion
        //--------------------------------------------


        //--------------------------------------------

        #region Proberties
        //--------------------------------------------


        /// <summary>

        /// Dauer in Sekunden

        /// </summary>

        public double Duration
        {
            get
            {
                return _duration;
            }
        }

        /// <summary>

        /// Frequenz des Timers, bzw. Anzahl der Inkremente, welcher der

        /// Performance-Timer pro Sekunde ausführt 

        /// </summary>

        public long Freqeuncy
        {
            get
            {
                return _freq;
            }
        }

        /// <summary>

        /// Endzeitpunkt der Messung in Millisekunden seit dem letzten Systemstart

        /// </summary>

        public long StopTime
        {
            get
            {
                return _stopTime;
            }
        }

        /// <summary>

        /// Startzeitpunkt der Messung in Millisekunden seit dem letzten Systemstart

        /// </summary>

        public long StartTime
        {
            get
            {
                return _startTime;
            }
        }


        //--------------------------------------------

        #endregion
        //--------------------------------------------


        //--------------------------------------------

        #region Initialisation
        //--------------------------------------------


        /// <summary>

        /// Standardkonstruktor.

        /// Setzt Frequenz des Timers und wirft eine Win32Exception,

        /// falls kein High-Performance Timer existiert.

        /// </summary>

        public Timer()
        {
            _startTime = 0;
            _stopTime = 0;
            _duration = 0;

            if (Timer.QueryPerformanceFrequency(out _freq) == false)
            {
                // high-performance counter not supported

                throw new Win32Exception(); ;
            }
        }

        //--------------------------------------------

        #endregion
        //--------------------------------------------


        //--------------------------------------------

        #region Methods
        //--------------------------------------------


        /// <summary>

        /// QueryPerformanceCounter stellt fest, wie viele Millisekunden seit dem letzten Systemstart

        /// vergangen sind und legt diese in bestmöglicher auflösung in einem 64-Bit Wert ab.

        /// </summary>

        /// <param name="lpPerformanceCount">

        /// Ein Zeiger auf einen 64-Bit Wert, in dem der Wert des Perfomance-Timers abgelegt wird.

        /// Dabei handelt es sich um eine 64-Bit Zahl, die die Zeit seit dem Systemstart in der

        /// bestmöglichen Auflösung mißt.

        /// </param>

        /// <returns>

        /// true  - Es gibt einen hochauflösenden Performance-Timer im System.

        /// false - Das System bietet den angeforderten Timer nicht.

        /// </returns>

        [DllImport("Kernel32.dll")]
        private static extern bool QueryPerformanceCounter(out long lpPerformanceCount);

        /// <summary>

        /// QueryPerformanceFrequency legt die Auflösung des hochauflösenden Performance-Timers fest.

        /// </summary>

        /// <param name="lpFrequency">

        /// Zeiger auf eine vorzeichenlose 64-Bit Zahl, die die Anzahl der Inkremente bestimmt die der

        /// Performance-Timer pro Sekunde ausführt.

        /// </param>

        /// <returns>

        /// true  - Es gibt einen hochauflösenden Performance-Timer im System.

        /// false - Das System bietet den angeforderten Timer nicht.

        /// </returns>

        [DllImport("Kernel32.dll")]
        private static extern bool QueryPerformanceFrequency(out long lpFrequency);

        /// <summary>

        /// Startet die Zeitmessung

        /// </summary>

        public void Start()
        {
            // lets do the waiting threads there work

            Thread.Sleep(0);

            // messen

            Timer.QueryPerformanceCounter(out _startTime);
        }

        /// <summary>

        /// Stopt die Zeitmessung

        /// </summary>

        public void Stop()
        {
            // messen

            Timer.QueryPerformanceCounter(out _stopTime);

            long spanne = _stopTime - _startTime;
            // zeitspanne errechnen

            _duration = (double)spanne / (double)_freq;
        }

        //--------------------------------------------

        #endregion
        //--------------------------------------------

    }
}