comment définir la résolution du timer à partir de C# à 1 ms?

J'ai utilisé cet outil et remarqué que mon Serveur Windows 2008 R2 Standard de 15 ms, alors que Windows 8 a un pas de 1 ms à rebours.

Je préfère régler la Minuterie Résolution de 1 ms sur Windows Server 2008 R2, car je suis en cours d'exécution faible latence de logiciels.

J'ai trouvé cette article msdn, mais elle n'explique pas comment changer la résolution du Timer à partir d'un programme C#. Comment dois-je faire?

Je crois que la résolution du timer est limité sur certaines architectures (c'est à dire que vous ne pouvez pas régler plus bas). Ici c'est un article sur comment mettre en place votre propre timer haute résolution pour Windows (avec exemple de code).
avez-vous lu "l'Obtention et le Réglage de la Résolution du Timer" article référencé dans la question?
Oui. Si vous lisez l'article que j'ai lié, il explique comment la résolution est limitée en fonction de l'architecture. Vous pouvez obtenir une meilleure résolution, mais il y a des compromis que vous avez à faire aussi bien. (Vous ne pouvez pas définir une décision arbitraire, sans le risque de perdre certains de précision).
Cet article de blog, Windows la Résolution du Timer: Mégawatts Gaspillée parle de certains des avantages et des inconvénients de l'évolution de la minuterie à l'aide timeBeginPeriod() et timeEndPeriod() et mentionne également le changement dans Windows 8 pour la résolution du timer.

OriginalL'auteur javapowered | 2013-02-25

  1. 12

    Vous pouvez essayer ceci:

    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);
}

    Et de l'utiliser comme ceci:

    WinApi.TimeBeginPeriod(1);

    Et de revenir à la façon dont il a été:

    WinApi.TimeEndPeriod(1);
    dois-je appeler cette fonction à chaque fois le système redémarré? ou je devrais l'appeler une seule fois?
    Chaque fois que vous démarrez le système. Ce n'est pas persisté - mais c' est global (c'est à dire il aura une incidence sur tous les processus)!
    J'ai utilisé cette méthode - il affecter Dort, et les OS de la minuterie, cependant Threading.Minuterie conserve sa 15ms résolution - plus de détails dans ma question ici: stackoverflow.com/questions/23215970/...
    Pour être précis, l'effet de TimeBeginPeriod dure jusqu'à ce que vous appelez TimeEndPeriod ou jusqu'à ce que votre processus se termine. Donc, vous l'appelez à l'initialisation du processus de temps. Si vous n'avez pas besoin de la minuterie de la fréquence soulevées pendant un certain temps, alors vous devrait, idéalement, appel TimeEndPeriod pour éviter de gaspiller de la puissance, et ensuite appeler TimeBeginPeriod quand vous en avez besoin de nouveau soulevée.

    OriginalL'auteur Matthew Watson

  2. 8

    Meilleur code pour mettre en œuvre ce serait:

    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;
}
}

    L'utiliser via:

    using (new TimePeriod(1))
{
////...
}

    OriginalL'auteur nick.lowe