在.NET 中检测 Windows 版本

如何检测.NET 中的 Windows 操作系统版本？

我能用什么代码？

156994 次浏览
小开

通过“获取包含当前平台标识符和版本号的 System.OperatingSystem 对象”的 Environment.OSVersion

小开
最佳答案

System.Environment.OSVersion 有区分大多数 Windows OS 主要版本所需的信息，但不是全部。它由三个组件组成，这些组件映射到以下 Windows 版本:

+------------------------------------------------------------------------------+
|                    |   PlatformID    |   Major version   |   Minor version   |
+------------------------------------------------------------------------------+
| Windows 95         |  Win32Windows   |         4         |          0        |
| Windows 98         |  Win32Windows   |         4         |         10        |
| Windows Me         |  Win32Windows   |         4         |         90        |
| Windows NT 4.0     |  Win32NT        |         4         |          0        |
| Windows 2000       |  Win32NT        |         5         |          0        |
| Windows XP         |  Win32NT        |         5         |          1        |
| Windows 2003       |  Win32NT        |         5         |          2        |
| Windows Vista      |  Win32NT        |         6         |          0        |
| Windows 2008       |  Win32NT        |         6         |          0        |
| Windows 7          |  Win32NT        |         6         |          1        |
| Windows 2008 R2    |  Win32NT        |         6         |          1        |
| Windows 8          |  Win32NT        |         6         |          2        |
| Windows 8.1        |  Win32NT        |         6         |          3        |
+------------------------------------------------------------------------------+
| Windows 10         |  Win32NT        |        10         |          0        |
+------------------------------------------------------------------------------+

有一个库可以让您更完整地了解当前执行环境运行的 Windows 的 一模一样版本，请查看 这个图书馆。

重要提示 : 如果您的可执行程序集清单没有明确说明您的 exe 程序集与 Windows 8.1和 Windows 10.0兼容，System.Environment.OSVersion将返回 Windows 8版本，即6.2，而不是6.3和10.0！资料来源: 给你。

更新 : 在.NET 5.0及更高版本中，System.Environment.OSVersion总是返回实际的操作系统版本。

小开

当我需要确定不同的微软操作系统版本时，我使用了这种方法:

string getOSInfo()
{
//Get Operating system information.
OperatingSystem os = Environment.OSVersion;
//Get version information about the os.
Version vs = os.Version;


//Variable to hold our return value
string operatingSystem = "";


if (os.Platform == PlatformID.Win32Windows)
{
//This is a pre-NT version of Windows
switch (vs.Minor)
{
case 0:
operatingSystem = "95";
break;
case 10:
if (vs.Revision.ToString() == "2222A")
operatingSystem = "98SE";
else
operatingSystem = "98";
break;
case 90:
operatingSystem = "Me";
break;
default:
break;
}
}
else if (os.Platform == PlatformID.Win32NT)
{
switch (vs.Major)
{
case 3:
operatingSystem = "NT 3.51";
break;
case 4:
operatingSystem = "NT 4.0";
break;
case 5:
if (vs.Minor == 0)
operatingSystem = "2000";
else
operatingSystem = "XP";
break;
case 6:
if (vs.Minor == 0)
operatingSystem = "Vista";
else if (vs.Minor == 1)
operatingSystem = "7";
else if (vs.Minor == 2)
operatingSystem = "8";
else
operatingSystem = "8.1";
break;
case 10:
operatingSystem = "10";
break;
default:
break;
}
}
//Make sure we actually got something in our OS check
//We don't want to just return " Service Pack 2" or " 32-bit"
//That information is useless without the OS version.
if (operatingSystem != "")
{
//Got something.  Let's prepend "Windows" and get more info.
operatingSystem = "Windows " + operatingSystem;
//See if there's a service pack installed.
if (os.ServicePack != "")
{
//Append it to the OS name.  i.e. "Windows XP Service Pack 3"
operatingSystem += " " + os.ServicePack;
}
//Append the OS architecture.  i.e. "Windows XP Service Pack 3 32-bit"
//operatingSystem += " " + getOSArchitecture().ToString() + "-bit";
}
//Return the information we've gathered.
return operatingSystem;
}

资料来源: 给你

小开

一种方法是:

public string GetOSVersion()
{
int _MajorVersion = Environment.OSVersion.Version.Major;


switch (_MajorVersion) {
case 5:
return "Windows XP";
case 6:
switch (Environment.OSVersion.Version.Minor) {
case 0:
return "Windows Vista";
case 1:
return "Windows 7";
default:
return "Windows Vista & above";
}
break;
default:
return "Unknown";
}
}

然后简单地在函数周围包装一个选择大小写。

小开

就像 R.Bemrose 建议的那样，如果你正在做 Windows7的特定功能，你应该看看 用于 Microsoft.NETFramework 的 WindowsAPI 代码包。

它包含一个 CoreHelpers类，可以让您确定当前使用的操作系统(仅适用于 XP 及以上版本，它是。)

它还提供了多个助手方法。例如，假设您想使用 Windows7的跳转列表，有一个类 TaskbarManager提供一个名为 IsPlatformSupported的属性，如果您在 Windows7及以上版本，它将返回 true。

小开

您可以使用这个助手类;

using System;
using System.Runtime.InteropServices;


/// <summary>
/// Provides detailed information about the host operating system.
/// </summary>
public static class OSInfo
{
#region BITS
/// <summary>
/// Determines if the current application is 32 or 64-bit.
/// </summary>
public static int Bits
{
get
{
return IntPtr.Size * 8;
}
}
#endregion BITS


#region EDITION
private static string s_Edition;
/// <summary>
/// Gets the edition of the operating system running on this computer.
/// </summary>
public static string Edition
{
get
{
if (s_Edition != null)
return s_Edition;  //***** RETURN *****//


string edition = String.Empty;


OperatingSystem osVersion = Environment.OSVersion;
OSVERSIONINFOEX osVersionInfo = new OSVERSIONINFOEX();
osVersionInfo.dwOSVersionInfoSize = Marshal.SizeOf( typeof( OSVERSIONINFOEX ) );


if (GetVersionEx( ref osVersionInfo ))
{
int majorVersion = osVersion.Version.Major;
int minorVersion = osVersion.Version.Minor;
byte productType = osVersionInfo.wProductType;
short suiteMask = osVersionInfo.wSuiteMask;


#region VERSION 4
if (majorVersion == 4)
{
if (productType == VER_NT_WORKSTATION)
{
// Windows NT 4.0 Workstation
edition = "Workstation";
}
else if (productType == VER_NT_SERVER)
{
if ((suiteMask & VER_SUITE_ENTERPRISE) != 0)
{
// Windows NT 4.0 Server Enterprise
edition = "Enterprise Server";
}
else
{
// Windows NT 4.0 Server
edition = "Standard Server";
}
}
}
#endregion VERSION 4


#region VERSION 5
else if (majorVersion == 5)
{
if (productType == VER_NT_WORKSTATION)
{
if ((suiteMask & VER_SUITE_PERSONAL) != 0)
{
// Windows XP Home Edition
edition = "Home";
}
else
{
// Windows XP / Windows 2000 Professional
edition = "Professional";
}
}
else if (productType == VER_NT_SERVER)
{
if (minorVersion == 0)
{
if ((suiteMask & VER_SUITE_DATACENTER) != 0)
{
// Windows 2000 Datacenter Server
edition = "Datacenter Server";
}
else if ((suiteMask & VER_SUITE_ENTERPRISE) != 0)
{
// Windows 2000 Advanced Server
edition = "Advanced Server";
}
else
{
// Windows 2000 Server
edition = "Server";
}
}
else
{
if ((suiteMask & VER_SUITE_DATACENTER) != 0)
{
// Windows Server 2003 Datacenter Edition
edition = "Datacenter";
}
else if ((suiteMask & VER_SUITE_ENTERPRISE) != 0)
{
// Windows Server 2003 Enterprise Edition
edition = "Enterprise";
}
else if ((suiteMask & VER_SUITE_BLADE) != 0)
{
// Windows Server 2003 Web Edition
edition = "Web Edition";
}
else
{
// Windows Server 2003 Standard Edition
edition = "Standard";
}
}
}
}
#endregion VERSION 5


#region VERSION 6
else if (majorVersion == 6)
{
int ed;
if (GetProductInfo( majorVersion, minorVersion,
osVersionInfo.wServicePackMajor, osVersionInfo.wServicePackMinor,
out ed ))
{
switch (ed)
{
case PRODUCT_BUSINESS:
edition = "Business";
break;
case PRODUCT_BUSINESS_N:
edition = "Business N";
break;
case PRODUCT_CLUSTER_SERVER:
edition = "HPC Edition";
break;
case PRODUCT_DATACENTER_SERVER:
edition = "Datacenter Server";
break;
case PRODUCT_DATACENTER_SERVER_CORE:
edition = "Datacenter Server (core installation)";
break;
case PRODUCT_ENTERPRISE:
edition = "Enterprise";
break;
case PRODUCT_ENTERPRISE_N:
edition = "Enterprise N";
break;
case PRODUCT_ENTERPRISE_SERVER:
edition = "Enterprise Server";
break;
case PRODUCT_ENTERPRISE_SERVER_CORE:
edition = "Enterprise Server (core installation)";
break;
case PRODUCT_ENTERPRISE_SERVER_CORE_V:
edition = "Enterprise Server without Hyper-V (core installation)";
break;
case PRODUCT_ENTERPRISE_SERVER_IA64:
edition = "Enterprise Server for Itanium-based Systems";
break;
case PRODUCT_ENTERPRISE_SERVER_V:
edition = "Enterprise Server without Hyper-V";
break;
case PRODUCT_HOME_BASIC:
edition = "Home Basic";
break;
case PRODUCT_HOME_BASIC_N:
edition = "Home Basic N";
break;
case PRODUCT_HOME_PREMIUM:
edition = "Home Premium";
break;
case PRODUCT_HOME_PREMIUM_N:
edition = "Home Premium N";
break;
case PRODUCT_HYPERV:
edition = "Microsoft Hyper-V Server";
break;
case PRODUCT_MEDIUMBUSINESS_SERVER_MANAGEMENT:
edition = "Windows Essential Business Management Server";
break;
case PRODUCT_MEDIUMBUSINESS_SERVER_MESSAGING:
edition = "Windows Essential Business Messaging Server";
break;
case PRODUCT_MEDIUMBUSINESS_SERVER_SECURITY:
edition = "Windows Essential Business Security Server";
break;
case PRODUCT_SERVER_FOR_SMALLBUSINESS:
edition = "Windows Essential Server Solutions";
break;
case PRODUCT_SERVER_FOR_SMALLBUSINESS_V:
edition = "Windows Essential Server Solutions without Hyper-V";
break;
case PRODUCT_SMALLBUSINESS_SERVER:
edition = "Windows Small Business Server";
break;
case PRODUCT_STANDARD_SERVER:
edition = "Standard Server";
break;
case PRODUCT_STANDARD_SERVER_CORE:
edition = "Standard Server (core installation)";
break;
case PRODUCT_STANDARD_SERVER_CORE_V:
edition = "Standard Server without Hyper-V (core installation)";
break;
case PRODUCT_STANDARD_SERVER_V:
edition = "Standard Server without Hyper-V";
break;
case PRODUCT_STARTER:
edition = "Starter";
break;
case PRODUCT_STORAGE_ENTERPRISE_SERVER:
edition = "Enterprise Storage Server";
break;
case PRODUCT_STORAGE_EXPRESS_SERVER:
edition = "Express Storage Server";
break;
case PRODUCT_STORAGE_STANDARD_SERVER:
edition = "Standard Storage Server";
break;
case PRODUCT_STORAGE_WORKGROUP_SERVER:
edition = "Workgroup Storage Server";
break;
case PRODUCT_UNDEFINED:
edition = "Unknown product";
break;
case PRODUCT_ULTIMATE:
edition = "Ultimate";
break;
case PRODUCT_ULTIMATE_N:
edition = "Ultimate N";
break;
case PRODUCT_WEB_SERVER:
edition = "Web Server";
break;
case PRODUCT_WEB_SERVER_CORE:
edition = "Web Server (core installation)";
break;
}
}
}
#endregion VERSION 6
}


s_Edition = edition;
return edition;
}
}
#endregion EDITION


#region NAME
private static string s_Name;
/// <summary>
/// Gets the name of the operating system running on this computer.
/// </summary>
public static string Name
{
get
{
if (s_Name != null)
return s_Name;  //***** RETURN *****//


string name = "unknown";


OperatingSystem osVersion = Environment.OSVersion;
OSVERSIONINFOEX osVersionInfo = new OSVERSIONINFOEX();
osVersionInfo.dwOSVersionInfoSize = Marshal.SizeOf( typeof( OSVERSIONINFOEX ) );


if (GetVersionEx( ref osVersionInfo ))
{
int majorVersion = osVersion.Version.Major;
int minorVersion = osVersion.Version.Minor;


switch (osVersion.Platform)
{
case PlatformID.Win32Windows:
{
if (majorVersion == 4)
{
string csdVersion = osVersionInfo.szCSDVersion;
switch (minorVersion)
{
case 0:
if (csdVersion == "B" || csdVersion == "C")
name = "Windows 95 OSR2";
else
name = "Windows 95";
break;
case 10:
if (csdVersion == "A")
name = "Windows 98 Second Edition";
else
name = "Windows 98";
break;
case 90:
name = "Windows Me";
break;
}
}
break;
}


case PlatformID.Win32NT:
{
byte productType = osVersionInfo.wProductType;


switch (majorVersion)
{
case 3:
name = "Windows NT 3.51";
break;
case 4:
switch (productType)
{
case 1:
name = "Windows NT 4.0";
break;
case 3:
name = "Windows NT 4.0 Server";
break;
}
break;
case 5:
switch (minorVersion)
{
case 0:
name = "Windows 2000";
break;
case 1:
name = "Windows XP";
break;
case 2:
name = "Windows Server 2003";
break;
}
break;
case 6:
switch (productType)
{
case 1:
name = "Windows Vista";
break;
case 3:
name = "Windows Server 2008";
break;
}
break;
}
break;
}
}
}


s_Name = name;
return name;
}
}
#endregion NAME


#region PINVOKE
#region GET
#region PRODUCT INFO
[DllImport( "Kernel32.dll" )]
internal static extern bool GetProductInfo(
int osMajorVersion,
int osMinorVersion,
int spMajorVersion,
int spMinorVersion,
out int edition );
#endregion PRODUCT INFO


#region VERSION
[DllImport( "kernel32.dll" )]
private static extern bool GetVersionEx( ref OSVERSIONINFOEX osVersionInfo );
#endregion VERSION
#endregion GET


#region OSVERSIONINFOEX
[StructLayout( LayoutKind.Sequential )]
private struct OSVERSIONINFOEX
{
public int dwOSVersionInfoSize;
public int dwMajorVersion;
public int dwMinorVersion;
public int dwBuildNumber;
public int dwPlatformId;
[MarshalAs( UnmanagedType.ByValTStr, SizeConst = 128 )]
public string szCSDVersion;
public short wServicePackMajor;
public short wServicePackMinor;
public short wSuiteMask;
public byte wProductType;
public byte wReserved;
}
#endregion OSVERSIONINFOEX


#region PRODUCT
private const int PRODUCT_UNDEFINED = 0x00000000;
private const int PRODUCT_ULTIMATE = 0x00000001;
private const int PRODUCT_HOME_BASIC = 0x00000002;
private const int PRODUCT_HOME_PREMIUM = 0x00000003;
private const int PRODUCT_ENTERPRISE = 0x00000004;
private const int PRODUCT_HOME_BASIC_N = 0x00000005;
private const int PRODUCT_BUSINESS = 0x00000006;
private const int PRODUCT_STANDARD_SERVER = 0x00000007;
private const int PRODUCT_DATACENTER_SERVER = 0x00000008;
private const int PRODUCT_SMALLBUSINESS_SERVER = 0x00000009;
private const int PRODUCT_ENTERPRISE_SERVER = 0x0000000A;
private const int PRODUCT_STARTER = 0x0000000B;
private const int PRODUCT_DATACENTER_SERVER_CORE = 0x0000000C;
private const int PRODUCT_STANDARD_SERVER_CORE = 0x0000000D;
private const int PRODUCT_ENTERPRISE_SERVER_CORE = 0x0000000E;
private const int PRODUCT_ENTERPRISE_SERVER_IA64 = 0x0000000F;
private const int PRODUCT_BUSINESS_N = 0x00000010;
private const int PRODUCT_WEB_SERVER = 0x00000011;
private const int PRODUCT_CLUSTER_SERVER = 0x00000012;
private const int PRODUCT_HOME_SERVER = 0x00000013;
private const int PRODUCT_STORAGE_EXPRESS_SERVER = 0x00000014;
private const int PRODUCT_STORAGE_STANDARD_SERVER = 0x00000015;
private const int PRODUCT_STORAGE_WORKGROUP_SERVER = 0x00000016;
private const int PRODUCT_STORAGE_ENTERPRISE_SERVER = 0x00000017;
private const int PRODUCT_SERVER_FOR_SMALLBUSINESS = 0x00000018;
private const int PRODUCT_SMALLBUSINESS_SERVER_PREMIUM = 0x00000019;
private const int PRODUCT_HOME_PREMIUM_N = 0x0000001A;
private const int PRODUCT_ENTERPRISE_N = 0x0000001B;
private const int PRODUCT_ULTIMATE_N = 0x0000001C;
private const int PRODUCT_WEB_SERVER_CORE = 0x0000001D;
private const int PRODUCT_MEDIUMBUSINESS_SERVER_MANAGEMENT = 0x0000001E;
private const int PRODUCT_MEDIUMBUSINESS_SERVER_SECURITY = 0x0000001F;
private const int PRODUCT_MEDIUMBUSINESS_SERVER_MESSAGING = 0x00000020;
private const int PRODUCT_SERVER_FOR_SMALLBUSINESS_V = 0x00000023;
private const int PRODUCT_STANDARD_SERVER_V = 0x00000024;
private const int PRODUCT_ENTERPRISE_SERVER_V = 0x00000026;
private const int PRODUCT_STANDARD_SERVER_CORE_V = 0x00000028;
private const int PRODUCT_ENTERPRISE_SERVER_CORE_V = 0x00000029;
private const int PRODUCT_HYPERV = 0x0000002A;
#endregion PRODUCT


#region VERSIONS
private const int VER_NT_WORKSTATION = 1;
private const int VER_NT_DOMAIN_CONTROLLER = 2;
private const int VER_NT_SERVER = 3;
private const int VER_SUITE_SMALLBUSINESS = 1;
private const int VER_SUITE_ENTERPRISE = 2;
private const int VER_SUITE_TERMINAL = 16;
private const int VER_SUITE_DATACENTER = 128;
private const int VER_SUITE_SINGLEUSERTS = 256;
private const int VER_SUITE_PERSONAL = 512;
private const int VER_SUITE_BLADE = 1024;
#endregion VERSIONS
#endregion PINVOKE


#region SERVICE PACK
/// <summary>
/// Gets the service pack information of the operating system running on this computer.
/// </summary>
public static string ServicePack
{
get
{
string servicePack = String.Empty;
OSVERSIONINFOEX osVersionInfo = new OSVERSIONINFOEX();


osVersionInfo.dwOSVersionInfoSize = Marshal.SizeOf( typeof( OSVERSIONINFOEX ) );


if (GetVersionEx( ref osVersionInfo ))
{
servicePack = osVersionInfo.szCSDVersion;
}


return servicePack;
}
}
#endregion SERVICE PACK


#region VERSION
#region BUILD
/// <summary>
/// Gets the build version number of the operating system running on this computer.
/// </summary>
public static int BuildVersion
{
get
{
return Environment.OSVersion.Version.Build;
}
}
#endregion BUILD


#region FULL
#region STRING
/// <summary>
/// Gets the full version string of the operating system running on this computer.
/// </summary>
public static string VersionString
{
get
{
return Environment.OSVersion.Version.ToString();
}
}
#endregion STRING


#region VERSION
/// <summary>
/// Gets the full version of the operating system running on this computer.
/// </summary>
public static Version Version
{
get
{
return Environment.OSVersion.Version;
}
}
#endregion VERSION
#endregion FULL


#region MAJOR
/// <summary>
/// Gets the major version number of the operating system running on this computer.
/// </summary>
public static int MajorVersion
{
get
{
return Environment.OSVersion.Version.Major;
}
}
#endregion MAJOR


#region MINOR
/// <summary>
/// Gets the minor version number of the operating system running on this computer.
/// </summary>
public static int MinorVersion
{
get
{
return Environment.OSVersion.Version.Minor;
}
}
#endregion MINOR


#region REVISION
/// <summary>
/// Gets the revision version number of the operating system running on this computer.
/// </summary>
public static int RevisionVersion
{
get
{
return Environment.OSVersion.Version.Revision;
}
}
#endregion REVISION
#endregion VERSION
}

示例代码如下:

    Console.WriteLine( "Operation System Information" );
Console.WriteLine( "----------------------------" );
Console.WriteLine( "Name = {0}", OSInfo.Name );
Console.WriteLine( "Edition = {0}", OSInfo.Edition );
Console.WriteLine( "Service Pack = {0}", OSInfo.ServicePack );
Console.WriteLine( "Version = {0}", OSInfo.VersionString );
Console.WriteLine( "Bits = {0}", OSInfo.Bits );

我被发现在这个地址: http://www.csharp411.com/wp-content/uploads/2009/01/OSInfo.cs

小开

不要把问题过分复杂化。

string osVer = System.Environment.OSVersion.Version.ToString();


if (osVer.StartsWith("5")) // windows 2000, xp win2k3
{
MessageBox.Show("xp!");
}
else // windows vista and windows 7 start with 6 in the version #
{
MessageBox.Show("Win7!");
}
小开

对于一个非常简单的函数，这些似乎都是非常复杂的答案:

public bool IsWindows7
{
get
{
return (Environment.OSVersion.Version.Major == 6 &
Environment.OSVersion.Version.Minor == 1);
}
}
小开
  1. 添加对 Microsoft.VisualBasic的引用。
  2. 包括名称空间 using Microsoft.VisualBasic.Devices;
  3. 使用 new ComputerInfo().OSFullName

返回值是“ MicrosoftWindows10企业版”

小开

使用注册表获取名称如何。

“ HKEY _ LOCAL _ MACHINE SOFTWARE MicrosoftWindowsNT CurrentVersion”自 WindowsXP 以来具有值 ProductName。

[DllImport("kernel32.dll")]
static extern IntPtr GetCurrentProcess();


[DllImport("kernel32.dll")]
static extern IntPtr GetModuleHandle(string moduleName);


[DllImport("kernel32")]
static extern IntPtr GetProcAddress(IntPtr hModule, string procName);


[DllImport("kernel32.dll")]
static extern bool IsWow64Process(IntPtr hProcess, out bool wow64Process);


public static bool Is64BitOperatingSystem()
{
// Check if this process is natively an x64 process. If it is, it will only run on x64 environments, thus, the environment must be x64.
if (IntPtr.Size == 8)
return true;
// Check if this process is an x86 process running on an x64 environment.
IntPtr moduleHandle = GetModuleHandle("kernel32");
if (moduleHandle != IntPtr.Zero)
{
IntPtr processAddress = GetProcAddress(moduleHandle, "IsWow64Process");
if (processAddress != IntPtr.Zero)
{
bool result;
if (IsWow64Process(GetCurrentProcess(), out result) && result)
return true;
}
}
// The environment must be an x86 environment.
return false;
}


private static string HKLM_GetString(string key, string value)
{
try
{
RegistryKey registryKey = Registry.LocalMachine.OpenSubKey(key);
return registryKey?.GetValue(value).ToString() ?? String.Empty;
}
catch
{
return String.Empty;
}
}


public static string GetWindowsVersion()
{
string osArchitecture;
try
{
osArchitecture = Is64BitOperatingSystem() ? "64-bit" : "32-bit";
}
catch (Exception)
{
osArchitecture = "32/64-bit (Undetermined)";
}
string productName = HKLM_GetString(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion", "ProductName");
string csdVersion = HKLM_GetString(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion", "CSDVersion");
string currentBuild = HKLM_GetString(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion", "CurrentBuild");
if (!string.IsNullOrEmpty(productName))
{
return
$"{productName}{(!string.IsNullOrEmpty(csdVersion) ? " " + csdVersion : String.Empty)} {osArchitecture} (OS Build {currentBuild})";
}
return String.Empty;
}

如果使用.NET Framework 4.0或更高版本。可以删除 Is64BitOperatingSystem ()方法并使用 64位操作系统。

小开

我使用名称空间 System.Management的 ManagementObjectSearcher

例如:

string r = "";
using (ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_OperatingSystem"))
{
ManagementObjectCollection information = searcher.Get();
if (information != null)
{
foreach (ManagementObject obj in information)
{
r = obj["Caption"].ToString() + " - " + obj["OSArchitecture"].ToString();
}
}
r = r.Replace("NT 5.1.2600", "XP");
r = r.Replace("NT 5.2.3790", "Server 2003");
MessageBox.Show(r);
}

不要忘记添加对程序集 System.Management.dll的引用 并把使用: using System.Management;

结果:

inserir a descrição da imagem aqui

文件

小开

检测操作系统版本:

    public static string OS_Name()
{
return (string)(from x in new ManagementObjectSearcher(
"SELECT Caption FROM Win32_OperatingSystem").Get().Cast<ManagementObject>()
select x.GetPropertyValue("Caption")).FirstOrDefault();
}
小开

这是一个相对较老的问题，但我最近不得不解决这个问题，并没有看到我的解决方案张贴在任何地方。

最简单(在我看来也是最简单的方法)就是使用对 RtlGetVersion 的 pcall 调用

[DllImport("ntdll.dll", SetLastError = true)]
internal static extern uint RtlGetVersion(out Structures.OsVersionInfo versionInformation); // return type should be the NtStatus enum


[StructLayout(LayoutKind.Sequential)]
internal struct OsVersionInfo
{
private readonly uint OsVersionInfoSize;


internal readonly uint MajorVersion;
internal readonly uint MinorVersion;


private readonly uint BuildNumber;


private readonly uint PlatformId;


[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
private readonly string CSDVersion;
}

此结构中的主版本号和次版本号与接受答案表中的值对应。

这将返回正确的 Windows 版本号，不同于 kernel32中已废弃的 GetVersion & GetVersionEx 函数

小开

.NET 5

从.NET5开始，Environment.OSVersion返回 Windows 和 macOS 操作系统的实际版本。

var version = Environment.OSVersion;
Console.WriteLine(version);


// Microsoft Windows NT 10.0.19044.0

Https://learn.microsoft.com/en-us/dotnet/core/compatibility/core-libraries/5.0/environment-osversion-returns-correct-version

旧版本的 dotnet:

为了确保使用 Environment.OSVersion得到正确的版本，您应该使用 视觉工作室添加一个 app.manifest，然后取消注释以下 supportedOS标记:

  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
<application>
<!-- A list of the Windows versions that this application has been tested on
and is designed to work with. Uncomment the appropriate elements
and Windows will automatically select the most compatible environment. -->


<!-- Windows Vista -->
<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}" />


<!-- Windows 7 -->
<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}" />


<!-- Windows 8 -->
<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}" />


<!-- Windows 8.1 -->
<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}" />


<!-- Windows 10 -->
<supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />


</application>
</compatibility>

然后你可以这样使用 Environment.OSVersion:

var version = Environment.OSVersion;
Console.WriteLine(version);


// Before: Microsoft Windows NT 6.2.9200.0
// After: Microsoft Windows NT 10.0.19044.0

例如，在我的机器(Windows 10.0 Build 19044)中没有清单文件，结果将是 6.2.9200.0，即 不正确。

通过添加 app.manifest文件和 取消注释那些标签我将得到正确的版本号是 10.0.19044.0。

另一种解决方案

如果您不喜欢将 app.manifest添加到您的项目中，您可以使用 OSDescription。NET Framework 4.7.1 + 和。NET 核心1。X + .

// using System.Runtime.InteropServices;
string description = RuntimeInformation.OSDescription;

您可以阅读有关它和支持的平台 给你的更多信息。

小开

上面的答案会给我在 Windows10上的 Major版本 6。

我发现不需要添加额外的 VB 库就可以工作的解决方案如下:

var versionString = (string)Microsoft.Win32.Registry.LocalMachine.OpenSubKey("Software\\Microsoft\\Windows NT\\CurrentVersion")?.GetValue("productName");

我不认为这是获得版本的最佳方式，但好处是这是一个线程没有额外的库，在我的情况下，检查它是否包含 "10"是足够好的。

小开

这个问题可以追溯到 WindowsXP 时代，问题和答案都经过了多年的编辑。

下面的代码使用.NETFramework 工作，并应检测 Windows10的所有版本。

基于这个问题和答案-(如何检查 Windows 版本的 C # 在.NET 5.0控制台应用程序)

using System;
using Microsoft.Win32;


namespace WindowsVersion
{
class Version
{
static void Main(string[] args)
{
string HKLMWinNTCurrent = @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion";
string osName = Registry.GetValue(HKLMWinNTCurrent, "productName", "").ToString();
string osRelease = Registry.GetValue(HKLMWinNTCurrent, "ReleaseId", "").ToString();
string osVersion = Environment.OSVersion.Version.ToString();
string osType = Environment.Is64BitOperatingSystem ? "64-bit" : "32-bit";
string osBuild = Registry.GetValue(HKLMWinNTCurrent, "CurrentBuildNumber", "").ToString();
string osUBR = Registry.GetValue(HKLMWinNTCurrent, "UBR", "").ToString();
Console.WriteLine("OS Name:" + osName);
Console.WriteLine("OS Release:" + osRelease);
Console.WriteLine("OS Version:" + osVersion);
Console.WriteLine("OS Type:" + osType);
Console.WriteLine("OS Build:" + osBuild);
Console.WriteLine("OS UBR:" + osUBR);
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
}
}
}

我已经在我的电脑上测试了它，结果如下。

result

有关 Windows10版本的列表，请参阅 Wikipedia 的这篇文章

Https://en.wikipedia.org/wiki/list_of_microsoft_windows_versions

Windows11的更新

根据这个链接，目前在注册表中没有任何地方举行的 Windows 产品名称。

Https://learn.microsoft.com/en-us/answers/questions/555857/windows-11-product-name-in-registry.html

作为解决方案，可以使用下面的代码片段-

    if (osBuild == "22000")
{
osFullName = "Windows 11";
}

在我的电脑上，它同时报告 Windows10和 Windows11。

小开

在阅读 WinAPI 文档时，我生成了一个静态类，它应该正确地返回操作系统版本的名称。我添加了一些来自 WinAPI 的注释和到文档的链接。

public static class OsVersionHelper
{


public static string GetWindowsVersion()
{
try
{
RtlGetVersion(out OuVersionInfoEXA versionInfo);
return versionInfo.GetOsVersionInfoToOsName();
}
catch (Exception ex)
{
Repl.WriteLine(ex.ToString(), ConsoleColor.White, ConsoleColor.Red);
return string.Empty;
}
}


/// <summary>
/// https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nf-wdm-rtlgetversion
/// </summary>
/// <param name="versionInformation">Pointer to either a RTL_OSVERSIONINFOW structure or a RTL_OSVERSIONINFOEXW structure that contains the version information about the currently running operating system. A caller specifies which input structure is used by setting the dwOSVersionInfoSize member of the structure to the size in bytes of the structure that is used.</param>
/// <returns>RtlGetVersion returns STATUS_SUCCESS.</returns>
[DllImport("ntdll.dll", SetLastError = true)]
internal static extern uint RtlGetVersion(out OuVersionInfoEXA versionInformation); // return type should be the NtStatus enum


/// <summary>
/// https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/ns-wdm-_osversioninfoexw
/// </summary>
///
/// <remarks>
/// Operating system        Version number  dwMajorVersion dwMinorVersion  Other
/// Windows 10              10.0*           10              0               OSVERSIONINFOEX.wProductType == VER_NT_WORKSTATION
/// Windows Server 2016     10.0*           10              0               OSVERSIONINFOEX.wProductType != VER_NT_WORKSTATION
/// Windows 8.1             6.3*            6               3               OSVERSIONINFOEX.wProductType == VER_NT_WORKSTATION
/// Windows Server 2012 R2  6.3*            6               3               OSVERSIONINFOEX.wProductType != VER_NT_WORKSTATION
/// Windows 8               6.2             6               2               OSVERSIONINFOEX.wProductType == VER_NT_WORKSTATION
/// Windows Server 2012     6.2             6               2               OSVERSIONINFOEX.wProductType != VER_NT_WORKSTATION
/// Windows 7               6.1             6               1               OSVERSIONINFOEX.wProductType == VER_NT_WORKSTATION
/// Windows Server 2008 R2  6.1             6               1               OSVERSIONINFOEX.wProductType != VER_NT_WORKSTATION
/// Windows Server 2008     6.0             6               0               OSVERSIONINFOEX.wProductType != VER_NT_WORKSTATION
/// Windows Vista           6.0             6               0               OSVERSIONINFOEX.wProductType == VER_NT_WORKSTATION
/// Windows Server 2003 R2  5.2             5               2               GetSystemMetrics(SM_SERVERR2) != 0
/// Windows Server 2003     5.2             5               2               GetSystemMetrics(SM_SERVERR2) == 0
/// Windows XP              5.1             5               1               Not applicable
/// Windows 2000            5.0             5               0               Not applicable
/// </remarks>


[StructLayout(LayoutKind.Sequential)]
internal struct OuVersionInfoEXA
{
private readonly uint OsVersionInfoSize;


internal readonly uint MajorVersion;
internal readonly uint MinorVersion;


private readonly uint BuildNumber;


private readonly uint PlatformId;


[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
private readonly string CSDVersion;


internal readonly ushort wServicePackMajor;
internal readonly ushort wServicePackMinor;
internal readonly ushort wSuiteMask;
internal readonly char wProductType;
private readonly char wReserved;
}


/// <summary>
/// https://learn.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_system_info
/// </summary>
private const byte VER_NT_WORKSTATION = 1;


internal static string GetOsVersionInfoToOsName(this in OuVersionInfoEXA info)
{
switch (info.MajorVersion)
{
case 10:
if (info.wProductType == VER_NT_WORKSTATION)
return "Windows 10";
else
return "Windows Server 2016";
case 6:
switch (info.MinorVersion)
{
case 3:
if (info.wProductType == VER_NT_WORKSTATION)
return "Windows 8.1";
else
return "Windows Server 2012 R2";
case 2:
if (info.wProductType == VER_NT_WORKSTATION)
return "Windows 8";
else
return "Windows Server 2012";


case 1:
if (info.wProductType == VER_NT_WORKSTATION)
return "Windows 7";
else
return "Windows Server 2008 R2";


case 0:
return "Windows Server 2008";


default:
return $"Unknown: {info.MajorVersion}:{info.MinorVersion}";
}
case 5:
switch (info.MinorVersion)
{
case 2:
if (GetSystemMetrics(SM_SERVERR2) != 0)
return "Windows Server 2003 R2";
else
return "Windows Server 2003";
case 1:
return "Windows XP";
case 0:
return "Windows 2000";
default:
return $"Unknown: {info.MajorVersion}:{info.MinorVersion}";
}
default:
return $"Unknown: {info.MajorVersion}:{info.MinorVersion}";
}


}


/// <summary>
/// https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getsystemmetrics
/// </summary>
[DllImport("user32.dll")]
static extern int GetSystemMetrics(uint smIndex);


internal const int SM_SERVERR2 = 89;


}
小开

我有一门课是关于这个的。
我根据 维基百科上的一篇文章编写了这个类 您可以在项目中使用这个类:

class Windows
{
public class Info
{
public string Name = "";
public string fullName = "";
public string UserAgent = "";
public string Type = "";
public string codeName = "";
public string Version = "";
public string buildNumber = "";
}


public static Info GetInfo()
{
string HKLMWinNTCurrent = @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion";
string osBuild = Registry.GetValue(HKLMWinNTCurrent, "CurrentBuildNumber", "").ToString();
string fullName = Registry.GetValue(HKLMWinNTCurrent, "productName", "").ToString();
string Type = Environment.Is64BitOperatingSystem ? "x64" : "x84";


string win11 = "Windows 11 version 21H2";
string win10 = "Windows 10 version ";
string win81 = "Windows 8.1";
string win8 = "Windows 8";
string win7 = "Windows 7";
string winVista = "Windows Vista";
string winXP = "Windows XP";
string winMe = "Windows Me";
string win98 = "Windows 98";
string win98_2 = "Windows 98 Second Edition";
string win2000 = "Windows 2000";


string v11 = "Windows NT 11";
string v10 = "Windows NT 10";
string v81 = "Windows NT 6.3";
string v8 = "Windows NT 6.2";
string v7 = "Windows NT 6.1";
string vVista = "Windows NT 6.0";
string vXP1 = "Windows NT 5.2";
string vXP = "Windows NT 5.1";
string vMe = "Windows NT 4.9";
string v98 = "Windows NT 4.1";
string v2000 = "Windows NT 5.0";




switch (osBuild)
{
case "22000":
return new Info()
{
Name = win11,
Version = "21H2",
UserAgent = v11,
buildNumber = "22000",
codeName = "Sun Valley",
fullName = fullName,
Type = Type
};
case "19044":
return new Info()
{
Name = win10 + "21H2",
Version = "21H2",
UserAgent = v10,
buildNumber = "19044",
codeName = "Vibranium",
fullName = fullName,
Type = Type
};
case "19043":
return new Info()
{
Name = win10 + "21H1",
Version = "21H1",
UserAgent = v10,
buildNumber = "19043",
codeName = "Vibranium",
fullName = fullName,
Type = Type
};
case "19042":
return new Info()
{
Name = win10 + "20H2",
Version = "20H2",
UserAgent = v10,
buildNumber = "19042",
codeName = "Vibranium",
fullName = fullName,
Type = Type
};
case "19041":
return new Info()
{
Name = win10 + "2004",
Version = "2004",
UserAgent = v10,
buildNumber = "19041",
codeName = "Vibranium",
fullName = fullName,
Type = Type
};
case "18363":
return new Info()
{
Name = win10 + "1909",
Version = "1909",
UserAgent = v10,
buildNumber = "18363",
codeName = "Vibranium",
fullName = fullName,
Type = Type
};
case "18362":
return new Info()
{
Name = win10 + "1903",
Version = "1903",
UserAgent = v10,
buildNumber = "18362",
codeName = "19H1",
fullName = fullName,
Type = Type
};
case "17763":
return new Info()
{
Name = win10 + "1809",
Version = "1809",
UserAgent = v10,
buildNumber = "17763",
codeName = "Redstone 5",
fullName = fullName,
Type = Type
};
case "17134":
return new Info()
{
Name = win10 + "1803",
Version = "1803",
UserAgent = v10,
buildNumber = "17134",
codeName = "Redstone 4",
fullName = fullName,
Type = Type
};
case "16299":
return new Info()
{
Name = win10 + "1709",
Version = "1709",
UserAgent = v10,
buildNumber = "16299",
codeName = "Redstone 3",
fullName = fullName,
Type = Type
};
case "15063":
return new Info()
{
Name = win10 + "1703",
Version = "1703",
UserAgent = v10,
buildNumber = "15063",
codeName = "Redstone 2",
fullName = fullName,
Type = Type
};
case "14393":
return new Info()
{
Name = win10 + "1607",
Version = "1607",
UserAgent = v10,
buildNumber = "14393",
codeName = "Redstone 1",
fullName = fullName,
Type = Type
};
case "10586":
return new Info()
{
Name = win10 + "1511",
Version = "1511",
UserAgent = v10,
buildNumber = "10586",
codeName = "Threshold 2",
fullName = fullName,
Type = Type
};
case "10240":
return new Info()
{
Name = win10 + "1507",
Version = "NT 10.0",
UserAgent = v10,
buildNumber = "10240",
codeName = "Threshold 1",
fullName = fullName,
Type = Type
};
case "9600":
return new Info()
{
Name = win81,
Version = "NT 6.3",
UserAgent = v81,
buildNumber = "9600",
codeName = "Blue",
fullName = fullName,
Type = Type
};
case "9200":
return new Info()
{
Name = win8,
Version = "NT 6.2",
UserAgent = v8,
buildNumber = "9200",
codeName = win8,
fullName = fullName,
Type = Type
};
case "7601":
return new Info()
{
Name = win7,
Version = "NT 6.1",
UserAgent = v7,
buildNumber = "7601",
codeName = win7,
fullName = fullName,
Type = Type
};
case "6002":
return new Info()
{
Name = winVista,
Version = "NT 6.0",
UserAgent = vVista,
buildNumber = "6002",
codeName = "Longhorn",
fullName = fullName,
Type = Type
};
case "2715":
return new Info()
{
Name = winXP,
Version = "NT 5.2",
UserAgent = vXP1,
buildNumber = "2715",
codeName = "Emerald",
fullName = fullName,
Type = Type
};
case "3790":
return new Info()
{
Name = winXP,
Version = "NT 5.2",
UserAgent = vXP1,
buildNumber = "3790",
codeName = "Anvil",
fullName = fullName,
Type = Type
};
case "2600":
return new Info()
{
Name = winXP,
Version = "NT 5.1",
UserAgent = vXP,
buildNumber = "2600",
codeName = "Symphony, Harmony, Freestyle, Whistler",
fullName = fullName,
Type = Type
};
case "3000":
return new Info()
{
Name = winMe,
Version = "4.9",
UserAgent = vMe,
buildNumber = "3000",
codeName = "Millennium",
fullName = fullName,
Type = Type
};
case "1998":
return new Info()
{
Name = win98,
Version = "4.10",
UserAgent = v98,
buildNumber = "1998",
codeName = "Memphis",
fullName = fullName,
Type = Type
};
case "2222":
return new Info()
{
Name = win98_2,
Version = "4.10",
UserAgent = v98,
buildNumber = "2222",
codeName = "Unknow",
fullName = fullName,
Type = Type
};
case "2195":
return new Info()
{
Name = win2000,
Version = "NT 5.0",
UserAgent = v2000,
buildNumber = "2195",
codeName = "Windows NT 5.0",
fullName = fullName,
Type = Type
};


default:
return new Info()
{
Name = "Unknow",
Version = "Unknow",
UserAgent = "Unknow",
buildNumber = "Unknow",
codeName = "Unknow"
};
}
}
}

关于使用这个,
var info = Windows.GetInfo();


Console.WriteLine($"Name: {info.Name}");
Console.WriteLine($"fullName: {info.fullName}");
Console.WriteLine($"UserAgent: {info.UserAgent}");
Console.WriteLine($"Type: {info.Type}");
Console.WriteLine($"codeName: {info.codeName}");
Console.WriteLine($"Version: {info.Version}");
Console.WriteLine($"buildNumber: {info.buildNumber}");

结果:
Name: Windows 10 version 21H2
fullName: Windows 10 Enterprise LTSC 2021
UserAgent: Windows NT 10
Type: x64
codeName: Vibranium
Version: 21H2
buildNumber: 19044

提交答案