반응형
에서 Windows 버전을 검출합니다.그물
에서 Windows OS 버전을 검출하려면 어떻게 해야 합니까?인터넷?
어떤 코드를 사용할 수 있습니까?
System.Environment.OSVersion 에는 Windows OS 메이저릴리즈의 모든 것을 구별하는 데 필요한 정보가 기재되어 있습니다.이 컴포넌트는 다음 Windows 버전에 매핑되는3개의 컴포넌트로 구성되어 있습니다.
+------------------------------------------------------------------------------+
| | 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는 6.3과 10.0이 아닌 6.2의 Windows 8 버전을 반환합니다.출처: 여기.
업데이트: .NET 5.0 이후에서는System.Environment.OSVersion는 항상 실제 OS 버전을 반환합니다.자세한 내용은 환경을 참조하십시오.OSVersion은 올바른 운영 체제 버전을 반환합니다.
다양한 Microsoft 운영 체제 버전을 결정해야 할 때 이 버전을 사용했습니다.
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;
}
출처: 여기
용 the the the를 .ManagementObjectSearcherSystem.Management
예:
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;
결과:
이것은 비교적 오래된 질문입니다만, 최근 이 문제를 해결해야 하는 상황이 되어 버렸습니다.해결책이 게재되어 있는 것을 알 수 없었습니다.
가장 쉬운 방법(내 생각에 가장 간단한 방법)은 RtlGetVersion에 대한 핀보크 호출을 사용하는 것입니다.
[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;
}
여기서 이 구조체의 Major 및 Minor 버전 번호는 승인된 응답 표의 값에 해당합니다.
그러면 kernel32에서 권장되지 않는 GetVersion 및 GetVersionEx 함수와 달리 올바른 Windows 버전 번호가 반환됩니다.
.NET 5
에서 시작합니다. 5, § 5,Environment.OSVersion및 합니다.
var version = Environment.OSVersion;
Console.WriteLine(version);
// Microsoft Windows NT 10.0.19044.0
이전 버전의 닷넷:
사용하여 Environment.OSVersion 해서 '부재하다'를 넣어야 요.app.manifestVisual Studio를 사용한 후 다음 주석 해제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+ " 1NET Core 1.x+
// using System.Runtime.InteropServices;
string description = RuntimeInformation.OSDescription;
자세한 내용은 여기에서 보실 수 있습니다.
이 도우미 클래스를 사용할 수 있습니다.
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();
에서 Windows 버전을 검출합니다.그물 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 주소에서 찾았습니다.
R. Bemrose가 제안했듯이 Windows 7의 특정 기능을 사용하는 경우 Microsoft®용 Windows® API Code Pack을 참조하십시오.NET 프레임워크
「 」가 포함되어 .CoreHelpers현재 사용하고 있는 OS를 판별할 수 있는 클래스(XP 이후만 해당)를 참조해 주세요.NET nowdayy)
또한 여러 도우미 방법도 제공합니다.를 들어,, 「 7」이 있다고 .TaskbarManager 있습니다.IsPlatformSupportedWindows 7 상가가가가가가가가가가가가가가가가 。
★★ Environment.OSVersion"시스템이 생깁니다.운영 체제 ID"
이 모든 것은 매우 간단한 기능으로는 매우 복잡한 답처럼 보입니다.
public bool IsWindows7
{
get
{
return (Environment.OSVersion.Version.Major == 6 &
Environment.OSVersion.Version.Minor == 1);
}
}
- 를 「」에 추가합니다.
Microsoft.VisualBasic. using Microsoft.VisualBasic.Devices;new ComputerInfo().OSFullName
반환값은 "Microsoft Windows 10 Enterprise" 입니다.
OS 버전 검색:
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();
}
이 질문은 Windows XP 시절로 거슬러 올라가며 질문과 답변 모두 수년간 편집되어 왔습니다.
다음 코드는 를 사용하여 동작합니다.NET Framework 및 Windows 10 의 모든 버전을 검출합니다.
이 질문과 답변을 바탕으로 (에서 C#의 Windows 버전을 확인하는 방법)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();
}
}
}
컴퓨터로 테스트해 본 결과는 다음과 같습니다.
Windows 10 버전 목록은 이 Wikipedia 문서를 참조하십시오.
https://en.wikipedia.org/wiki/List_of_Microsoft_Windows_versions
Windows 11 업데이트
이 링크에 따르면 현재 레지스트리에 Windows 제품 이름이 저장되어 있는 곳은 없습니다.
https://learn.microsoft.com/en-us/answers/questions/555857/windows-11-product-name-in-registry.html
회피책으로서 다음의 코드 fragment를 사용합니다.
if (osBuild == "22000")
{
osFullName = "Windows 11";
}
내 컴퓨터에서는 Windows 10과 Windows 11이 모두 표시됩니다.
편도:
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";
}
}
그런 다음 선택한 케이스를 함수에 감습니다.
위의 답변은 나에게 줄 것입니다.Major버전6를 참조해 주세요.
VB 라이브러리를 추가하지 않고 사용할 수 있는 솔루션은 다음과 같습니다.
var versionString = (string)Microsoft.Win32.Registry.LocalMachine.OpenSubKey("Software\\Microsoft\\Windows NT\\CurrentVersion")?.GetValue("productName");
이 버전을 얻는 최선의 방법은 아니지만, 좋은 점은 Oneliner에는 추가 라이브러리가 없다는 것입니다.또한 이 라이브러리가 포함되어 있는지 여부를 확인합니다."10"괜찮았어요.
레지스트리를 사용해서 이름을 알아보는 건 어때?
"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\"Windows NT\CurrentVersion"은 Windows XP 이후 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() 메서드를 삭제하고 환경을 사용할 수 있습니다.Is64Bit Operating System.
WinAPI 문서를 읽고 OS 버전 이름을 올바르게 반환하는 정적 클래스를 생성했습니다.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"
};
}
}
}
and about use this,
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}");
Result:
Name: Windows 10 version 21H2
fullName: Windows 10 Enterprise LTSC 2021
UserAgent: Windows NT 10
Type: x64
codeName: Vibranium
Version: 21H2
buildNumber: 19044
문제를 너무 복잡하게 만들지 마세요.
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!");
}
언급URL : https://stackoverflow.com/questions/2819934/detect-windows-version-in-net
반응형
'programing' 카테고리의 다른 글
| Bash 스크립트로 파일에 대한 세레독을 작성하려면 어떻게 해야 합니다. (0) | 2023.04.08 |
|---|---|
| 웹 사이트의 브라우저 탭 아이콘(favicon)을 추가하려면 어떻게 해야 합니까? (0) | 2023.04.08 |
| 도커: Alpine 기반 도커 이미지에서 bash를 사용하는 방법 (0) | 2023.04.08 |
| 디렉토리를 tar하지만 완전한 절대 경로를 아카이브에 저장하지 않음 (0) | 2023.04.08 |
| SQL Server의 datetime 필드의 기본값을 타임스탬프에 추가합니다. (0) | 2023.04.08 |