using System;
using System.Runtime.InteropServices;
using System.Collections.Generic;

namespace SharpKrush.Misc
{
    /// <summary>
    /// Gibt den FPS Wert, der in einem gewissen Intervall aktualisiert wird, zurück.
    /// </summary>
    public class FrameCounter
    {
        [DllImport("kernel32.dll")]
        private static extern bool QueryPerformanceCounter(out long lpPerformanceCount);

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

        private System.Windows.Forms.Timer _timer;
        private float _fps;    // Fps Wert der im Intervall mit dem actFps befüllt wird
        private float _avgFps;
        private float _minFps;
        private float _maxFps;

        private float _sum;
        private float _sumCount;

        private float _actFps; // aktueller Fps Wert (Nach dem Render Timing)
        private long _lastFrame;
        private long _freq;
        private long _currentFrame;
        private int _interval;

        /// <summary>
        /// Konstruktor
        /// </summary>
        /// <param name="interval">Intervall der Aktualisierung vom FPS Wert, in Millisekunden</param>
        public FrameCounter(int interval) {
            this._sum = 0f;
            this._sumCount = 0f;

            // Min- und MaxFps Werte default setzen
            this._minFps = 999; // Das eigentlich jeder Wert kleiner ist~
            this._maxFps = 0;

            this._timer = new System.Windows.Forms.Timer();
            this._timer.Start();
            this._timer.Tick += new EventHandler(this.OnTick);
            this._timer.Interval = interval;
        }

        /// <summary>
        /// Gibt den Fps Wert zurück
        /// </summary>
        public float Fps {
            get { return this._fps; }
        }

        /// <summary>
        /// Gibt den durchschnittlichen Fps Wert zurück
        /// </summary>
        public float AvgFps {
            get { return this._avgFps; }
        }

        /// <summary>
        /// Gibt den kleinsten Fps Wert zurück
        /// </summary>
        public float MinFps {
            get { return this._minFps; }
        }

        /// <summary>
        /// Gibt den grössenn Fps Wert zurück
        /// </summary>
        public float MaxFps {
            get { return this._maxFps; }
        }

        /// <summary>
        /// Intervall der Aktualisierung vom FPS Wert, in Millisekunden
        /// </summary>
        public int Interval {
            set { this._interval = value; }
        }

        /// <summary>
        /// Beginnt mit der Zeitmessung
        /// </summary>
        public void Begin() {
            QueryPerformanceFrequency(out this._freq);
            QueryPerformanceCounter(out this._lastFrame);
        }

        /// <summary>
        /// Berechnet am Ende des Renderns den aktuellen Fps Wert
        /// </summary>
        public void End() {
            QueryPerformanceCounter(out this._currentFrame);
            this._actFps = this._freq / (this._currentFrame - this._lastFrame);

            // Auf kleinsten Wert prüfen
            if (this._actFps < this._minFps) {
                this._minFps = this._actFps;
            }

            // Auf grössten Wert prüfen
            if (this._actFps > this._maxFps) {
                this._maxFps = this._actFps;
            }
        }

        /// <summary>
        /// Berechnet den durchschnittlichen Fps Wert
        /// </summary>
        private void CalculateAvgFps() {
            if (this._sumCount ≤ 600) {
                this._sum += this._fps;
                this._sumCount++;

                this._avgFps = this._sum / this._sumCount;
            } else {
                this._sum = 0;
                this._avgFps = 60;
            }
        }

        /// <summary>
        /// Nach jedem Intervall wird der FPS Wert hier aktualisiert
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnTick(object sender, EventArgs e) {
            this._fps = this._actFps;
            this.CalculateAvgFps();
        }
    }
}

Stopwatch sw = [...]
[...]
long ellapsedNanoSeconds = sw.EllapsedTicks / Stopwatch.Frequency;