c# - सी#में उच्च संकल्प टाइमर




timer high-resolution (2)

नई प्रणाली बनाने का प्रयास करें। System.Threading.Thread.SleepSystem.Threading.Thread और System.Threading.Thread का प्रयोग करके।

var thrd = new Syatem.Threading.Thread(() => {
    while (true) {
        // do something
        System.Threading.Thread.Sleep(1); // wait 1 ms
    }
});

thrd.Start();

क्या कोई उच्च रिज़ॉल्यूशन टाइमर है जो हर बार टाइमर समाप्त हो जाता है, जैसे कि System.TimerSystem.Timer वर्ग की तरह? मुझे हर एमएस के Elapse को एक उच्च संकल्प टाइमर की आवश्यकता है

मैं पदों में चल रहा हूं जो बताते हैं कि स्टॉपवॉच उच्च प्रस्तावों को माप सकता है, लेकिन मैं समय का आकलन नहीं करना चाहता, मैं 1 एमएस का अंतराल बनाना चाहता हूं।

क्या नेट पर कुछ है या क्या मैं अपना खुद का उच्च रिज़ टाइमर लिख रहा हूं?


इसमें कुछ भी नहीं है जो मैं जानता हूं। विंडोज में मल्टीमीडिया टाइमर एपीआई के माध्यम से उच्च रिज़ॉल्यूशन टाइमर इवेंट्स के लिए एक तंत्र है । नीचे एक त्वरित उदाहरण है जो मुझे काम करने के लिए प्रतीत होता है। यहां भी एक अच्छा उदाहरण लगता है

मैं नोट करेगा कि यह एपीआई सिस्टम की व्यापक सेटिंग्स को बदलती है जो सिस्टम प्रदर्शन को नीचा कर सकती हैं, इसलिए खरीदार सावधान रहना परीक्षण के प्रयोजनों के लिए, मैं इस बात को ध्यान में रखेगा कि समय की पुष्टि करने के लिए टाइमर कितनी बार गोलीबारी कर रहा है, डिवाइस को आप अनुकरण करने की कोशिश कर रहे हैं। खिड़कियां एक वास्तविक समय के ओएस नहीं हैं, इसलिए आपके सिस्टम पर भार से एमएम टाइमर को विलंब हो सकता है जिसके परिणामस्वरूप 100 एमएस के अंतराल का कारण बन सकता है जिसमें 100 उत्क्रांतियां होती हैं। एमएम टाइमर पर कुछ अतिरिक्त पठन

class Program
{
    static void Main(string[] args)
    {
        TestThreadingTimer();
        TestMultimediaTimer();
    }

    private static void TestMultimediaTimer()
    {
        Stopwatch s = new Stopwatch();
        using (var timer = new MultimediaTimer() { Interval = 1 })
        {
            timer.Elapsed += (o, e) => Console.WriteLine(s.ElapsedMilliseconds);
            s.Start();
            timer.Start();
            Console.ReadKey();
            timer.Stop();
        }
    }

    private static void TestThreadingTimer()
    {
        Stopwatch s = new Stopwatch();
        using (var timer = new Timer(o => Console.WriteLine(s.ElapsedMilliseconds), null, 0, 1))
        {
            s.Start();
            Console.ReadKey();
        }
    }

}

public class MultimediaTimer : IDisposable
{
    private bool disposed = false;
    private int interval, resolution;
    private UInt32 timerId; 

    // Hold the timer callback to prevent garbage collection.
    private readonly MultimediaTimerCallback Callback;

    public MultimediaTimer()
    {
        Callback = new MultimediaTimerCallback(TimerCallbackMethod);
        Resolution = 5;
        Interval = 10;
    }

    ~MultimediaTimer()
    {
        Dispose(false);
    }

    public int Interval
    {
        get
        {
            return interval;
        }
        set
        {
            CheckDisposed();

            if (value < 0)
                throw new ArgumentOutOfRangeException("value");

            interval = value;
            if (Resolution > Interval)
                Resolution = value;
        }
    }

    // Note minimum resolution is 0, meaning highest possible resolution.
    public int Resolution
    {
        get
        {
            return resolution;
        }
        set
        {
            CheckDisposed();

            if (value < 0)
                throw new ArgumentOutOfRangeException("value");

            resolution = value;
        }
    }

    public bool IsRunning
    {
        get { return timerId != 0; }
    }

    public void Start()
    {
        CheckDisposed();

        if (IsRunning)
            throw new InvalidOperationException("Timer is already running");

        // Event type = 0, one off event
        // Event type = 1, periodic event
        UInt32 userCtx = 0;
        timerId = NativeMethods.TimeSetEvent((uint)Interval, (uint)Resolution, Callback, ref userCtx, 1);
        if (timerId == 0)
        {
            int error = Marshal.GetLastWin32Error();
            throw new Win32Exception(error);
        }
    }

    public void Stop()
    {
        CheckDisposed();

        if (!IsRunning)
            throw new InvalidOperationException("Timer has not been started");

        StopInternal();
    }

    private void StopInternal()
    {
        NativeMethods.TimeKillEvent(timerId);
        timerId = 0;
    }

    public event EventHandler Elapsed;

    public void Dispose()
    {
        Dispose(true);
    }

    private void TimerCallbackMethod(uint id, uint msg, ref uint userCtx, uint rsv1, uint rsv2)
    {
        var handler = Elapsed;
        if (handler != null)
        {
            handler(this, EventArgs.Empty);
        }
    }

    private void CheckDisposed()
    {
        if (disposed)
            throw new ObjectDisposedException("MultimediaTimer");
    }

    private void Dispose(bool disposing)
    {
        if (disposed)
            return;

        disposed = true;
        if (IsRunning)
        {
            StopInternal();
        }

        if (disposing)
        {
            Elapsed = null;
            GC.SuppressFinalize(this);
        }
    }
}

internal delegate void MultimediaTimerCallback(UInt32 id, UInt32 msg, ref UInt32 userCtx, UInt32 rsv1, UInt32 rsv2);

internal static class NativeMethods
{
    [DllImport("winmm.dll", SetLastError = true, EntryPoint = "timeSetEvent")]
    internal static extern UInt32 TimeSetEvent(UInt32 msDelay, UInt32 msResolution, MultimediaTimerCallback callback, ref UInt32 userCtx, UInt32 eventType);

    [DllImport("winmm.dll", SetLastError = true, EntryPoint = "timeKillEvent")]
    internal static extern void TimeKillEvent(UInt32 uTimerId);
}




high-resolution