使用 C# 检索系统正常运行时间
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/972105/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
Retrieve system uptime using C#
提问by ProgrammingPope
Is there a simple way to get a system's uptime using C#?
有没有一种简单的方法可以使用 C# 获得系统的正常运行时间？
采纳答案by SLaks
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());
}
}
}
回答by C. Ross
Simple, no but it can be done:
简单，不，但可以做到：
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!");
}
回答by adrianbanks
System.Environment.TickCountgets the number of milliseconds since the system was restarted.
System.Environment.TickCount获取自系统重新启动以来的毫秒数。
Beware though that it is an Int32 and will overflow after 24.9 days and will become negative. See the remarks on the MDSN docs.
请注意，它是一个 Int32，将在 24.9 天后溢出并变为负数。请参阅 MDSN 文档上的备注。
回答by Jakub Chodounsky
The simplest and proper way to do this is
最简单和正确的方法是
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();
}
回答by Martin
I'm a bit late, but another simpleway is to use the GetTickCount64function, which is available starting with Windows Vista and does not overflow as GetTickCount does:
我有点晚了，但另一种简单的方法是使用GetTickCount64函数，该函数从 Windows Vista 开始可用，并且不会像 GetTickCount 那样溢出：
public static TimeSpan GetUpTime()
{
return TimeSpan.FromMilliseconds(GetTickCount64());
}
[DllImport("kernel32")]
extern static UInt64 GetTickCount64();
回答by BlackCap
I know question is both old and solved, but the esiest solution I can tink of is just using the Enviroment.TickCount property, which returns the number of millisecounds since the system started:
我知道问题既旧又已解决，但我能想到的最简单的解决方案就是使用 Enviroment.TickCount 属性，它返回自系统启动以来的毫秒数：
System.DateTime SystemStartTime = DateAndTime.Now.AddMilliseconds(-Environment.TickCount);
System.DateTime Uptime = DateAndTime.Now - SystemStartTime;
This solition is a lot faster than the accepted answare.
这种解决方案比公认的 answare 快得多。
回答by Rbjz
Precise and bigger than System.Environment.TickCount, not involving OS horrific perf counters, WMI or native calls:
精确且大于System.Environment.TickCount，不涉及操作系统可怕的性能计数器、WMI 或本机调用：
var ticks = Stopwatch.GetTimestamp();
var uptime = ((double)ticks) / Stopwatch.Frequency;
var uptimeSpan = TimeSpan.FromSeconds(uptime);
回答by Quantic
My machine has an uptime of 58 days 17 hoursaccording to Task Manager. I went through and tried each answer here and the fast ones are off by a little bit (~1-3 minutes roughly, but over 58 days of uptime):
58 days 17 hours根据任务管理器，我的机器有正常运行时间。我仔细研究并尝试了这里的每个答案，快速的答案有一点点（大约 1-3 分钟，但正常运行时间超过 58 天）：
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
The last two, using PerformanceCounter or using ManagementObject, are always within the same second as Windows Task Manager (just have to take my word for it, or try it yourself with the code below). Based on the results I am going to use the ManagementObject LastBootUpTimemethod because it's drastically faster than the PerformanceCounterbut is still perfectly accurate when compared to Task Manager.
最后两个，使用 PerformanceCounter 或使用 ManagementObject，总是与 Windows 任务管理器在同一秒内（只需要相信我的话，或者自己尝试使用下面的代码）。根据结果，我将使用该ManagementObject LastBootUpTime方法，因为它比PerformanceCounter任务管理器快得多，但与任务管理器相比仍然非常准确。
Note that I did subtract the current elapsed time from each method before printing the times, but the whole thing takes less than 2 seconds to run so the time shift can't be explained by improperly accounting for execution time anyway. Here's the code I used:
请注意，在打印时间之前，我确实从每个方法中减去了当前经过的时间，但整个过程运行时间不到 2 秒，因此无论如何不能通过不正确地考虑执行时间来解释时间偏移。这是我使用的代码：
[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}");
}
回答by Robin Davies
The (one and only) correct answer so far:
到目前为止（唯一的）正确答案：
Using the 32-bit timer is incredibly dangerous, and prone to error for all but limited use.
使用 32 位计时器非常危险，并且在使用有限的情况下容易出错。
I'm not sure when the NativeMethods class stuff was added to .net, but it was. You definitely want to avoid P/Invoke overhead. Do this:
我不确定何时将 NativeMethods 类的东西添加到 .net 中，但确实如此。您肯定希望避免 P/Invoke 开销。做这个：
using System;
using System.Runtime.InteropServices;
namespace Mu
{
// prevents PInvoke (not in NativeMethods class) or Stack walk (NativeMethods class) performance penalties.
internal static partial class SafeNativeMethods
{
[DllImport("kernel32")]
internal extern static UInt64 GetTickCount64();
}
public static class MuTime
{
public static UInt64 UpTimeMillis { get { return SafeNativeMethods.GetTickCount64(); } }
}
}
/*
Dual License (use either, not both). To avoid CC-BY-SA, access a copy of this
code at (https://pastebin.com/6EKTWsSf) to use under BSD 0-clause license,
Copyright (c) 2020 Robin Davies
CC-BY-SA 3.0 (due to StackExchange terms of use). Not my fault, blame StackExchange. Fix this
please, StackExchange!
BSD 0-Clause
Copyright 2020 Robin Davies.
Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,
OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
THIS SOFTWARE.
*/
