wie stellen Sie die timer-Auflösung von C# zu 1 ms?

Ich verwendet habe, dieses tool und bemerkt, dass meine Windows Server 2008 R2 Standard hat ein 15 ms Auflösung, während Windows 8 hat eine Auflösung von 1 ms timer.

Ich würde es vorziehen, um die Timer-Auflösung bis 1 ms auf Windows Server 2008 R2, denn ich bin mit low-latency-software.

Ich habe festgestellt, das msdn-Artikel, aber es wird nicht erklärt, wie Sie zum ändern der Timer-Auflösung aus einem C# - Programm. Wie mache ich das?

  • Ich glaube, dass die timer-Auflösung ist begrenzt auf bestimmten Architekturen (d.h. man kann nicht einfach setzen Sie ihn auf einen niedrigeren). Hier ist ein Artikel darüber, wie zu implementieren Ihre eigenen high-resolution-timer für Windows (mit code-Beispiel).
  • hast du gelesen "die Beschaffung und Einstellung der Timer-Auflösung" - Artikel verwiesen in der Frage?
  • Ja. Wenn du den Artikel gelesen den ich verlinkt, es wird erläutert, wie die Auflösung ist begrenzt, nach der Architektur. Erhalten Sie eine bessere Auflösung, aber es gibt Kompromisse, die Sie haben, um Sie als gut. (Sie können nicht einfach legen Sie eine beliebige Auflösung, ohne das Potenzial zu verlieren, gewissen Genauigkeit).
  • Dieser blog-Artikel Windows-Timer-Auflösung: Megawatt Verschwendet diskutiert einige vor-und Nachteile der änderung der timer mit timeBeginPeriod() und timeEndPeriod() und erwähnt auch die änderung in Windows 8 für die timer-Auflösung.
InformationsquelleAutor javapowered | 2013-02-25
  1. 13

    Können Sie versuchen, diese:

    public static class WinApi
{
    ///<summary>TimeBeginPeriod(). See the Windows API documentation for details.</summary>

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Interoperability", "CA1401:PInvokesShouldNotBeVisible"), System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2118:ReviewSuppressUnmanagedCodeSecurityUsage"), SuppressUnmanagedCodeSecurity]
    [DllImport("winmm.dll", EntryPoint="timeBeginPeriod", SetLastError=true)]

    public static extern uint TimeBeginPeriod(uint uMilliseconds);

    ///<summary>TimeEndPeriod(). See the Windows API documentation for details.</summary>

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Interoperability", "CA1401:PInvokesShouldNotBeVisible"), System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2118:ReviewSuppressUnmanagedCodeSecurityUsage"), SuppressUnmanagedCodeSecurity]
    [DllImport("winmm.dll", EntryPoint="timeEndPeriod", SetLastError=true)]

    public static extern uint TimeEndPeriod(uint uMilliseconds);
}

    Und verwenden Sie es wie diese:

    WinApi.TimeBeginPeriod(1);

    Und gehen zurück zu wie es war:

    WinApi.TimeEndPeriod(1);
    • sollte ich diese Funktion aufrufen, jedes mal, wenn system neu gestartet? oder sollte ich nenne es einfach mal?
    • Wann immer Sie Ihr system starten. Es ist nicht dauerhaft - aber Sie ist global (d.h. es wirkt sich auf alle Prozesse)!
    • Ich habe diese Methode verwendet - es berührt Schläft, und OS-timer, jedoch Threading.Timer hält seine 15ms Auflösung - mehr details in meiner Frage hier: stackoverflow.com/questions/23215970/...
    • Um genau zu sein, die Wirkung von TimeBeginPeriod dauert, bis Sie rufen TimeEndPeriod oder bis Ihr Prozess endet. So, Sie in der Regel nennen es, bei der Initialisierung Prozess Zeit. Wenn Sie nicht brauchen, die timer-Frequenz angehoben, für eine Weile, dann sollten Sie idealerweise call TimeEndPeriod zu vermeiden, verschwenden Energie, und rufen Sie dann TimeBeginPeriod, wenn Sie es brauchen wieder angehoben.
    InformationsquelleAutor Matthew Watson
  2. 9

    Besseren code zu implementieren wäre dies:

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

internal sealed class TimePeriod : IDisposable
{
    private const string WINMM = "winmm.dll";

    private static TIMECAPS timeCapabilities;

    private static int inTimePeriod;

    private readonly int period;

    private int disposed;

    [DllImport(WINMM, ExactSpelling = true)]
    private static extern int timeGetDevCaps(ref TIMECAPS ptc, int cbtc);

    [DllImport(WINMM, ExactSpelling = true)]
    private static extern int timeBeginPeriod(int uPeriod);

    [DllImport(WINMM, ExactSpelling = true)]
    private static extern int timeEndPeriod(int uPeriod);

    static TimePeriod()
    {
        int result = timeGetDevCaps(ref timeCapabilities, Marshal.SizeOf(typeof(TIMECAPS)));
        if (result != 0)
        {
            throw new InvalidOperationException("The request to get time capabilities was not completed because an unexpected error with code " + result + " occured.");
        }
    }

    internal TimePeriod(int period)
    {
        if (Interlocked.Increment(ref inTimePeriod) != 1)
        {
            Interlocked.Decrement(ref inTimePeriod);
            throw new NotSupportedException("The process is already within a time period. Nested time periods are not supported.");
        }

        if (period < timeCapabilities.wPeriodMin || period > timeCapabilities.wPeriodMax)
        {
            throw new ArgumentOutOfRangeException("period", "The request to begin a time period was not completed because the resolution specified is out of range.");
        }

        int result = timeBeginPeriod(period);
        if (result != 0)
        {
            throw new InvalidOperationException("The request to begin a time period was not completed because an unexpected error with code " + result + " occured.");
        }

        this.period = period;
    }

    internal static int MinimumPeriod
    {
        get
        {
            return timeCapabilities.wPeriodMin;
        }
    }

    internal static int MaximumPeriod
    {
        get
        {
            return timeCapabilities.wPeriodMax;
        }
    }

    internal int Period
    {
        get
        {
            if (this.disposed > 0)
            {
                throw new ObjectDisposedException("The time period instance has been disposed.");
            }

            return this.period;
        }
    }

    public void Dispose()
    {
        if (Interlocked.Increment(ref this.disposed) == 1)
        {
            timeEndPeriod(this.period);
            Interlocked.Decrement(ref inTimePeriod);
        }
        else
        {
            Interlocked.Decrement(ref this.disposed);
        }
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct TIMECAPS
    {
        internal int wPeriodMin;

        internal int wPeriodMax;
    }
}

    Via:

    using (new TimePeriod(1))
{
    ////...
}
    InformationsquelleAutor nick.lowe
Schreibe einen Kommentar