Wie kann ich die Windows-Betriebssystemversionen in .net erkennen?
Welchen Code kann ich verwenden?
Windows-Version in .net erkennen
Antworten:
System.Environment.OSVersionverfügt über die Informationen, die Sie zur Unterscheidung der meisten Hauptversionen des Windows-Betriebssystems benötigen, jedoch nicht aller. Es besteht aus drei Komponenten, die den folgenden Windows-Versionen zugeordnet sind:
+------------------------------------------------------------------------------+
| | 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 |
+------------------------------------------------------------------------------+Für eine Bibliothek , die Ihnen einen vollständigen Überblick über das erhalten können genaue Version von Windows , dass die aktuelle Ausführungsumgebung in ausgeführt wird , überprüfen Sie diese Bibliothek .
Wichtiger Hinweis : Wenn in Ihrem ausführbaren Assemblymanifest nicht ausdrücklich angegeben ist, dass Ihre exe-Assembly mit Windows 8.1 und Windows 10.0 kompatibel ist, System.Environment.OSVersionwird die Windows 8-Version 6.2 anstelle von 6.3 und 10.0 zurückgegeben! Quelle: hier .
8
Diese Tabelle ist zumindest teilweise falsch, was die Antwort (ursprünglich über Win7) falsch macht . Die Leute stimmen ab, ohne zu prüfen, ob es tatsächlich funktioniert. Win7 hat keine Moll von 2 auf meinem Computer. Ich bin auf Win7 SP1 und meine Versionsinformationen zeigen "Microsoft Windows NT 6.1.7601 Service Pack 1". Wenn Sie sich Environment.OSVersion ansehen, erhalten Sie Build = 7601, Major = 6, MajorRevision = 1, Minor = 1, MinorRevision = 0, Revision = 65536.
—
Scobi
Ich stimme anderen zu. Dies beantwortet die Frage nicht wirklich. Gabes Antwort lautet
—
Andrew Ensley
@ Andrew er und ich haben die gleiche Antwort für Windows 7, nur seine Adresse spricht nicht wirklich an, dass Windows 2008 mit diesen bestimmten Attributen identisch aussieht
—
Daniel DiPaolo
Gut, jetzt sollten Sie die Tabelle auch mit Windows 8 und dem neuesten Windows Server (2012) aktualisieren :)
—
Davide Piras
Muss es immer mit dem Löffel gefüttert werden? System.Environment.OSVersion, das ist genau dort Ihre Antwort. Alles, was Sie tun müssen, ist zu verstehen, wie das funktioniert, und Sie können Ihre Methode zum Erkennen der Windows-Version schreiben. Sie werden kein erfolgreicher Entwickler, wenn Sie nur Codes aus dem Internet kopieren und einfügen können.
—
Jayson Ragasa
Ich habe dies verwendet, als ich verschiedene Microsoft-Betriebssystemversionen ermitteln musste:
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;
}Quelle: hier
Was ist mit der Methode getOSArchitecture ()? Fehler: "Der Name 'getOSArchitecture' ist im aktuellen Kontext nicht vorhanden."
—
Lonnie Best
@LonnieBest - Das ist eine Methode, die bestimmt, ob es x64 oder x86 ist ... Ich habe das nicht verwendet, kommentiere es einfach aus.
—
Gabe
vs.Minor != 0muss nicht unbedingt sein XPoder 7. Es kann sich um eine dieser Server-Editionen handeln, die dieselben Nebenversionen haben. Siehe hier msdn.microsoft.com/en-us/library/windows/desktop/…
Ich habe Windows 10 hier und es kehrt als Windows 8 zurück.
—
Matheus Miranda
@MatheusMiranda - siehe Wichtiger Hinweis am Ende der akzeptierten Antwort: "Wichtiger Hinweis: Wenn in Ihrem ausführbaren Assemblymanifest nicht ausdrücklich angegeben ist, dass Ihre exe-Assembly mit Windows 8.1 und Windows 10.0 kompatibel ist, gibt System.Environment.OSVersion die Windows 8.0-Version zurück ?! das ist 6.2 statt 6.3 und 10.0 !! "
—
ToolmakerSteve
Ich benutze den ManagementObjectSearcherof-NamespaceSystem.Management
Beispiel:
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);
}Vergessen Sie nicht, den Verweis auf die Baugruppe hinzuzufügen
System.Management.dllund Folgendes zu verwenden:using System.Management;
Ergebnis:
Perfekt, dies sollte als Antwort markiert werden, andere Lösungen sind inkonsistent. + 1
—
Bravo
Das hat bei mir funktioniert.
—
Jhollman
Wie R. Bemrose vorgeschlagen hat, sollten Sie sich bei Windows 7-spezifischen Funktionen das Windows® API Code Pack für Microsoft® .NET Framework ansehen .
Es enthält eine CoreHelpersKlasse, mit der Sie das Betriebssystem bestimmen können, auf dem Sie sich gerade befinden (nur XP und höher, dies ist heutzutage eine Voraussetzung für .NET).
Es bietet auch mehrere Hilfsmethoden. Angenommen, Sie möchten die Sprungliste von Windows 7 verwenden. Es gibt eine Klasse TaskbarManager, die eine Eigenschaft namens "bereitstellt" IsPlatformSupported, die unter Windows 7 und höher true zurückgibt.
Sie können diese Hilfsklasse verwenden.
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
}Beispielcode ist hier:
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 );Ich wurde unter folgender Adresse gefunden: http://www.csharp411.com/wp-content/uploads/2009/01/OSInfo.cs
Ja, dieser Code ist für die Hauptversion 6 unvollständig. Er benötigt eine Nebenversion der Nebenversion sowie den vorhandenen Produkttyp zum Einschalten. (6.0 und 6.1 bedeuten je nach Produkttyp unterschiedliche Bedeutungen.)
—
Beladung
Haben Sie es von hier genommen: csharp411.com/wp-content/uploads/2009/01/OSInfo.cs ? Bitte geben Sie Kredit ..
—
Nawfal
Beachten Sie, dass die Liste der Versionsausgaben veraltet ist. Eine aktualisierte Liste kann aus der Tabelle unter msdn.microsoft.com/en-us/library/windows/desktop/…
—
Sean Duggan
Dies alles scheint eine sehr komplizierte Antwort für eine sehr einfache Funktion zu sein:
public bool IsWindows7
{
get
{
return (Environment.OSVersion.Version.Major == 6 &
Environment.OSVersion.Version.Minor == 1);
}
}
Hinweis: Dies wird auch True für Windows Server 2008 R2
—
Matt Wilko
Dies ist eine relativ alte Frage, aber ich musste dieses Problem kürzlich lösen und habe meine Lösung nirgendwo veröffentlicht.
Der einfachste (und meiner Meinung nach einfachste) Weg ist, einfach einen Pinvoke-Aufruf von RtlGetVersion zu verwenden
[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;
}Wobei die Haupt- und Nebenversionsnummern in dieser Struktur den Werten in der Tabelle der akzeptierten Antwort entsprechen.
Dies gibt die korrekte Windows-Versionsnummer zurück, im Gegensatz zu den veralteten GetVersion- und GetVersionEx-Funktionen von kernel32
IMO, das ist die beste Antwort. Für die Verwendung von .Nets Environment.OSVersion muss Ihr Manifest bearbeitet werden, damit es ordnungsgemäß funktioniert. Für die Verwendung von WMI müssen zusätzliche Abhängigkeiten eingeführt werden. Einfach, unkompliziert und unkompliziert.
—
Andrew Rondeau
- Verweis auf hinzufügen
Microsoft.VisualBasic. - Namespace einschließen
using Microsoft.VisualBasic.Devices; - Verwenden
new ComputerInfo().OSFullName
Der Rückgabewert ist "Microsoft Windows 10 Enterprise".
Einweg:
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";
}
}Wickeln Sie dann einfach einen ausgewählten Fall um die Funktion.
Nicht relevant für den ursprünglichen Beitrag, aber wenn die Hauptversion 5 ist, haben Sie drei mögliche Versionen von Windows: 5.0 = Windows 2000, 5.1 = 32-Bit Windows XP, 5.2 = Windows Server 2003 oder 64-Bit Windows XP
—
BACON
Wie wäre es mit einer Registrierung, um den Namen zu erhalten.
"HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion" hat seit Windows XP den Wert 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;
}Wenn Sie .NET Framework 4.0 oder höher verwenden. Sie können die Is64BitOperatingSystem () -Methode entfernen und Environment.Is64BitOperatingSystem verwenden .
Erste Lösung
Um sicherzustellen, dass Sie die richtige Version erhalten Environment.OSVersion, sollten Sie eine app.manifestmit Visual Studio hinzufügen und folgende supportedOSTags auskommentieren :
<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>Dann können Sie in Ihrem Code Folgendes verwenden Environment.OSVersion:
var version = System.Environment.OSVersion;
Console.WriteLine(version);Beispiel
Zum Beispiel wäre in my machine ( Windows 10.0 Build 18362.476) das Ergebnis wie folgt, was falsch ist :
Microsoft Windows NT 6.2.9200.0Durch Hinzufügen app.manifestund Kommentieren dieser Tags erhalte ich die richtige Versionsnummer:
Microsoft Windows NT 10.0.18362.0Alternative Lösung
Wenn Sie app.manifestIhrem Projekt nicht gerne etwas hinzufügen möchten, können Sie das verwenden, OSDescriptiondas seit .NET Framework 4.7.1 und .NET Core 1.0 verfügbar ist.
string description = RuntimeInformation.OSDescription;Hinweis: Vergessen Sie nicht, die folgende using-Anweisung oben in Ihre Datei einzufügen.
using System.Runtime.InteropServices;Weitere Informationen und unterstützte Plattformen finden Sie hier .
Die obigen Antworten würden mir eine MajorVersion 6unter Windows 10 geben.
Die Lösung, die ich gefunden habe, ohne zusätzliche VB-Bibliotheken hinzuzufügen, war folgende:
var versionString = (string)Microsoft.Win32.Registry.LocalMachine.OpenSubKey("Software\\Microsoft\\Windows NT\\CurrentVersion")?.GetValue("productName");Ich würde dies nicht als den besten Weg betrachten, um die Version zu erhalten, aber der Vorteil ist, dass dies keine zusätzlichen Bibliotheken sind, und in meinem Fall "10"war es gut genug, zu prüfen, ob sie enthalten sind .
Machen Sie das Problem nicht zu kompliziert.
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!");
}
Äh, wenn es mit 5 beginnt, habe ich eine 1: 3-Chance, das Betriebssystem zu erraten?
—
Jimmy D
-1 dafür, weil Sie die Version in eine Zeichenfolge konvertieren und mit einer Zahlenzeichenfolge vergleichen, wenn Sie gerade den
—
Matt Wilko
MajorTeil der Version hätten vergleichen können. Außerdem wird "Win7!" unter einem Windows NT / Me / 98/95-Betriebssystem. Es wird auch nicht gut mit zukünftigen Versionen von Betriebssystemen fertig
Lehrbuchbeispiel, wie man solche Probleme nicht löst.
—
Leichtigkeitsrennen im Orbit