example - Recuperar el tiempo de actividad del sistema usando C#

summary example c#

Question

¿Hay una manera simple de obtener el tiempo de actividad de un sistema usando C #?

Answer 1

Estoy un poco tarde, pero otra forma simple es usar la función GetTickCount64 , que está disponible comenzando con Windows Vista y no se desborda, ya que GetTickCount sí:

public static TimeSpan GetUpTime()
{
    return TimeSpan.FromMilliseconds(GetTickCount64());
}

[DllImport("kernel32")]
extern static UInt64 GetTickCount64();

Answer 2

La manera más simple y adecuada de hacer esto es

public static TimeSpan GetUptime()
{
    ManagementObject mo = new ManagementObject(@"//./root/cimv2:Win32_OperatingSystem=@");
    DateTime lastBootUp = ManagementDateTimeConverter.ToDateTime(mo["LastBootUpTime"].ToString());
    return DateTime.Now.ToUniversalTime() - lastBootUp.ToUniversalTime();
}

Answer 3

Mi máquina tiene un tiempo de actividad de 58 days 17 hours según el Administrador de tareas. Pasé e intenté cada respuesta aquí y las rápidas se terminaron un poco (~ 1-3 minutos aproximadamente, pero más de 58 días de tiempo de actividad):

Stopwatch.GetTimeStamp(): 58days 17hours 11minutes 25seconds ~Time to calculate (ms): 6.8413 DllImport GetTickCount64(): 58days 17hours 13minutes 34seconds ~Time to calculate (ms): 0.2192 PerformanceCounter(System, System Up Time): 58days 17hours 14minutes 02seconds ~Time to calculate (ms): 1233.2854 ManagementObject LastBootUpTime: 58days 17hours 14minutes 02seconds ~Time to calculate (ms): 30.0283

Los dos últimos, usando PerformanceCounter o usando ManagementObject, siempre están dentro del mismo segundo que el Administrador de tareas de Windows (solo tengo que tomar mi palabra, o inténtalo tú mismo con el código siguiente). En base a los resultados, voy a utilizar el método ManagementObject LastBootUpTime porque es mucho más rápido que el PerformanceCounter pero sigue siendo perfectamente preciso en comparación con el Administrador de tareas.

Tenga en cuenta que restamos el tiempo transcurrido actual de cada método antes de imprimir los tiempos, pero tarda menos de 2 segundos en ejecutarse, por lo que el cambio de horario no se puede explicar contabilizando incorrectamente el tiempo de ejecución de todos modos. Aquí está el código que utilicé:

[System.Runtime.InteropServices.DllImport("kernel32")]
extern static UInt64 GetTickCount64();

public static void Main()
{
    var start = Stopwatch.StartNew();

    var eachStart = Stopwatch.StartNew();
    var ticks = Stopwatch.GetTimestamp();
    var uptime = ((double)ticks) / Stopwatch.Frequency;
    var uptimeTimeSpan = TimeSpan.FromSeconds(uptime);
    Console.WriteLine("Stopwatch.GetTimeStamp():                   " + uptimeTimeSpan.Subtract(start.Elapsed).ToString(@"dd/d/a/y/s/ hh/h/o/u/r/s/ mm/m/i/n/u/t/e/s/ ss/s/e/c/o/n/d/s"));
    Console.WriteLine($"~Time to calculate (ms): {eachStart.Elapsed.TotalMilliseconds}");

    eachStart.Restart();
    Console.WriteLine("DllImport GetTickCount64():                 " + TimeSpan.FromMilliseconds(GetTickCount64()).Subtract(start.Elapsed).ToString(@"dd/d/a/y/s/ hh/h/o/u/r/s/ mm/m/i/n/u/t/e/s/ ss/s/e/c/o/n/d/s"));
    Console.WriteLine($"~Time to calculate (ms): {eachStart.Elapsed.TotalMilliseconds}");

    eachStart.Restart();
    var upTime = new PerformanceCounter("System", "System Up Time");
    upTime.NextValue();       //Call this an extra time before reading its value
    Console.WriteLine("PerformanceCounter(System, System Up Time): " + TimeSpan.FromSeconds(upTime.NextValue()).Subtract(start.Elapsed).ToString(@"dd/d/a/y/s/ hh/h/o/u/r/s/ mm/m/i/n/u/t/e/s/ ss/s/e/c/o/n/d/s"));
    Console.WriteLine($"~Time to calculate (ms): {eachStart.Elapsed.TotalMilliseconds}");

    eachStart.Restart();
    ManagementObject mo = new ManagementObject(@"//./root/cimv2:Win32_OperatingSystem=@");
    DateTime lastBootUp = ManagementDateTimeConverter.ToDateTime(mo["LastBootUpTime"].ToString());
    Console.WriteLine("ManagementObject LastBootUpTime:            " + (DateTime.Now.ToUniversalTime() - lastBootUp.ToUniversalTime()).Subtract(start.Elapsed).ToString(@"dd/d/a/y/s/ hh/h/o/u/r/s/ mm/m/i/n/u/t/e/s/ ss/s/e/c/o/n/d/s"));
    Console.WriteLine($"~Time to calculate (ms): {eachStart.Elapsed.TotalMilliseconds}");
}

Answer 4

Preciso y más grande que System.Environment.TickCount , que no incluye los horribles contadores de rendimiento del sistema operativo, WMI o llamadas nativas:

var ticks = Stopwatch.GetTimestamp();
var uptime = ((double)ticks) / Stopwatch.Frequency;
var uptimeSpan = TimeSpan.FromSeconds(uptime);

Answer 5

Sé que la pregunta es antigua y está resuelta, pero la solución más simple que puedo probar es simplemente usar la propiedad Enviroment.TickCount, que devuelve la cantidad de milisegundos desde que se inició el sistema:

System.DateTime SystemStartTime = DateAndTime.Now.AddMilliseconds(-Environment.TickCount);
System.DateTime Uptime = DateAndTime.Now - SystemStartTime;

Esta solución es mucho más rápida que el answare aceptado.

Answer 6

Simple, no, pero se puede hacer:

    static DateTime getLastBootTime(ManagementObject mObject)
    {
        PropertyData pd = mObject.Properties["LastBootUpTime"];
        string name = pd.Name.ToString();
        DateTime lastBoot = parseCmiDateTime(pd.Value.ToString());
        return lastBoot;
    }

    static ManagementObject getServerOSObject(string serverName)
    {
        ManagementObjectSearcher mSearcher = new ManagementObjectSearcher("Select * From Win32_OperatingSystem");
        mSearcher.Scope = new ManagementScope(String.Format(@"//{0}/root/cimv2", serverName));
        ManagementObjectCollection mObjects = mSearcher.Get();
        if (mObjects.Count != 1) throw new Exception(String.Format("Expected 1 object, returned {0}.", mObjects.Count));
        foreach (ManagementObject m in mObjects)
        {
            //No indexing on collection
            return m;
        }
        throw new Exception("Something went wrong!");
    }

Answer 7

System.Environment.TickCount obtiene la cantidad de milisegundos desde que se reinició el sistema.

Sin embargo, ten en cuenta que es un Int32 y se desbordará después de 24.9 días y se volverá negativo. Vea los comentarios en los documentos de MDSN.

Answer 8

public TimeSpan UpTime {
    get {
        using (var uptime = new PerformanceCounter("System", "System Up Time")) {
            uptime.NextValue();       //Call this an extra time before reading its value
            return TimeSpan.FromSeconds(uptime.NextValue());
        }
    }
}