it-swarm.com.de

Wie erhalte ich den "freundlichen" OS-Versionsnamen?

Ich suche nach einer eleganten Möglichkeit, die Betriebssystemversion zu erhalten: "Windows XP Professional Service Pack 1" oder "Windows Server 2008 Standard Edition" usw. 

Gibt es eine elegante Möglichkeit, dies zu tun? 

Ich interessiere mich auch für die Prozessorarchitektur (wie x86 oder x64).

52
Stefan Koell

Sie können WMI verwenden, um den Produktnamen ("Microsoft® Windows Server® 2008 Enterprise") abzurufen:

using System.Management;
var name = (from x in new ManagementObjectSearcher("SELECT Caption FROM Win32_OperatingSystem").Get().Cast<ManagementObject>()
                      select x.GetPropertyValue("Caption")).FirstOrDefault();
return name != null ? name.ToString() : "Unknown";
64
Sean Kearon

Sie sollten wirklich versuchen, WMI für die lokale Verwendung zu vermeiden. Es ist sehr bequem, aber Sie zahlen teuer dafür. Das geht schnell und einfach:

    public string HKLM_GetString(string path, string key)
    {
        try
        {
            RegistryKey rk = Registry.LocalMachine.OpenSubKey(path);
            if (rk == null) return "";
            return (string)rk.GetValue(key);
        }
        catch { return ""; }
    }

    public string FriendlyName()
    {
        string ProductName = HKLM_GetString(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion", "ProductName");
        string CSDVersion = HKLM_GetString(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion", "CSDVersion");
        if (ProductName != "")
        {
            return (ProductName.StartsWith("Microsoft") ? "" : "Microsoft ") + ProductName +
                        (CSDVersion != "" ? " " + CSDVersion : "");
        }
        return "";
    }
24
domskey

Warum nicht Environment.OSVersion verwenden? Außerdem erfahren Sie, was für ein Betrieb dies ist - Windows, Mac OS X, Unix usw. Um herauszufinden, ob Sie 64-Bit oder 32-Bit verwenden, verwenden Sie IntPtr.Size -. Dies gibt 4 Byte für 32 Bit und 8 Byte für zurück 64bit.

21
configurator

Versuchen:

new ComputerInfo().OSVersion;

Ausgabe:  

Microsoft Windows 10 Enterprise

Hinweis: Referenz zu Microsoft.VisualBasic.Devices; hinzufügen

9
Niklas Peter

Beispielausgabe:

Name = Windows Vista
Edition = Home Premium
Service Pack = Service Pack 1
Version = 6.0.6001.65536
Bits = 64

Musterklasse:

class Program
{
    static void Main( string[] args )
    {
        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 );
        Console.ReadLine();
    }
}

Quellcode für die OSInfo-Klasse: http://www.csharp411.com/determine-windows-version-and-edition-with-c/ Es gibt jedoch einen Fehler im Code. Sie müssen das " case 6 "-Anweisung (vor #endregion NAME) mit folgender Anweisung:

case 6:
    switch (minorVersion)
    {
        case 0:

            switch (productType)
            {
                case 1:
                    name = "Windows Vista";
                    break;
                case 3:
                    name = "Windows Server 2008";
                    break;
            }
            break;
        case 1:
            switch (productType)
            {
                case 1:
                    name = "Windows 7";
                    break;
                case 3:
                    name = "Windows Server 2008 R2";
                    break;
            }
            break;
    }
    break;

Und wenn Sie noch einen Schritt weiter gehen und sehen möchten, ob Ihr Programm in 64 oder 32 Bit läuft:

public static class Wow
{
    public static bool Is64BitProcess
    {
        get { return IntPtr.Size == 8; }
    }

    public static bool Is64BitOperatingSystem
    {
        get
        {
            // Clearly if this is a 64-bit process we must be on a 64-bit OS.
            if (Is64BitProcess)
                return true;
            // Ok, so we are a 32-bit process, but is the OS 64-bit?
            // If we are running under Wow64 than the OS is 64-bit.
            bool isWow64;
            return ModuleContainsFunction("kernel32.dll", "IsWow64Process") && IsWow64Process(GetCurrentProcess(), out isWow64) && isWow64;
        }
    }

    static bool ModuleContainsFunction(string moduleName, string methodName)
    {
        IntPtr hModule = GetModuleHandle(moduleName);
        if (hModule != IntPtr.Zero)
            return GetProcAddress(hModule, methodName) != IntPtr.Zero;
        return false;
    }

    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    extern static bool IsWow64Process(IntPtr hProcess, [MarshalAs(UnmanagedType.Bool)] out bool isWow64);
    [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    extern static IntPtr GetCurrentProcess();
    [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
    extern static IntPtr GetModuleHandle(string moduleName);
    [DllImport("kernel32.dll", CharSet = CharSet.Ansi, SetLastError = true)]
    extern static IntPtr GetProcAddress(IntPtr hModule, string methodName);
}
7
Orwellophile

Eine Sache, auf die Sie achten sollten, ist, dass diese Informationen normalerweise lokalisiert sind und je nach Sprache des Betriebssystems unterschiedlich angezeigt werden. 

Sie können viele Informationen von WMI nach der Win32_OperatingSystem Klasse erhalten

3
JoshBerke

Beachten Sie, dass die Frage der Prozessorarchitektur komplex ist:

meinst du (höhere Zahlen erfordern niedrigere Zahlen, um wahr zu sein):

  1. Die CPU ist für die Verarbeitung von 64 Bit (in dem Sinne, dass sie AMD/Intel x64 oder Itanium unterstützt) geeignet.
  2. Das Betriebssystem ist 64bit
    • GPR und Zeiger sind 64 Bit, d. H. XP 64, Vista 64, ein 64-Bit-Server-Release oder ein 64-Bit-Betriebssystem für Mono
  3. Der aktuell ausgeführteProzess ist ein 64-Bit-Prozess (wird beispielsweise nicht unter Wow64 ausgeführt)

wenn Sie glücklich sind, dass alle 3 dann wahr sein müssen 

IntPtr.Size == 8

Gibt an, dass alle drei zutreffen

2
ShuggyCoUk

Etwas spät, aber so habe ich es gemacht. Könnte jemand in der Zukunft helfen. 

using Microsoft.Win32;

RegistryKey registryKey = Registry.LocalMachine.OpenSubKey("Software\\Microsoft\\Windows NT\\CurrentVersion");
        string pathName = (string)registryKey.GetValue("productName");
1
Noah

Ich weiß, es ist keine direkte Antwort auf die Frage und es ist auch ein bisschen spät, aber für diejenigen, die nur nach einem Weg suchen, um festzustellen, ob das Betriebssystem ein Client-Betriebssystem oder ein Server ist, gibt es eine Möglichkeit, Folgendes zu verwenden: Sie müssen die System.Management-Referenz angeben.

        using System;
        using System.Management;

        ManagementClass osClass = new ManagementClass("Win32_OperatingSystem");
        foreach (ManagementObject queryObj in osClass.GetInstances())
        {

            foreach (PropertyData prop in queryObj.Properties)
            {

                if (prop.Name == "ProductType")
                {

                    ProdType = int.Parse(prop.Value.ToString());
                }
            }
        }

die Variable ProdType ist eine Ganzzahl, die zuvor initialisiert wurde. Sie enthält einen Wert zwischen 1 und 3, während 1 für Workstation, 2 für Domänencontroller und 3 für einen Server steht.

Dies wurde aus Zugriff auf die Eigenschaften von Win32_OperatingSystem übernommen und ein wenig geändert ...

1
josibu

Sie können Visual Basic-Geräte verwenden, um Versionsinformationen abzurufen.

Code:  

using Microsoft.VisualBasic.Devices;

var versionID = new ComputerInfo().OSVersion;//6.1.7601.65536
var versionName = new ComputerInfo().OSFullName;//Microsoft Windows 7 Ultimate
var verionPlatform = new ComputerInfo().OSPlatform;//WinNT

Console.WriteLine(versionID);
Console.WriteLine(versionName);
Console.WriteLine(verionPlatform);

Ausgabe:  

6.1.7601.65536

Microsoft Windows 10 Enterprise

WinNT

Hinweis: Sie müssen einen Verweis auf Microsoft.VisualBasic; hinzufügen.

1
Suit Boy Apps

Offenlegung: Nachdem ich dies gepostet hatte, wurde mir klar, dass ich auf eine Nuget-Erweiterungsmethodenbibliothek namens Z.ExntensionMethods angewiesen bin, die IndexOf()

using Microsoft.VisualBasic.Devices;

string SimpleOSName()
{
    var name = new ComputerInfo().OSFullName;
    var parts = name.Split(' ').ToArray();
    var take = name.Contains("Server")?3:2;
    return string.Join(" ", parts.Skip(parts.IndexOf("Windows")).Take(take));
}

Schnellere Leistung using System.Management;

string SimpleOSName()
{
    var name = new ManagementObjectSearcher("SELECT Caption FROM Win32_OperatingSystem")
        .Get().Cast<ManagementObject>()
        .Select(x => x.GetPropertyValue("Caption").ToString())
        .First();
    var parts = name.Split(' ').ToArray();
    var take = name.Contains("Server")?3:2;
    return string.Join(" ", parts.Skip(parts.IndexOf("Windows")).Take(take));
}

ausgabebeispiel: 

Windows 7

Windows Server 2008

0
K. R.