web-dev-qa-db-fra.com

Comment obtenir le nom de version "convivial" du système d'exploitation?

Je recherche un moyen élégant d’obtenir la version du système d’exploitation telle que: "Windows XP Professional Service Pack 1" ou "Windows Server 2008 Standard Edition", etc. 

Y a-t-il une manière élégante de faire cela? 

Je suis également intéressé par l'architecture du processeur (comme x86 ou x64).

c#.netwinformsoperating-system
52
Stefan Koell

Vous pouvez utiliser WMI pour obtenir le nom du produit ("Microsoft® Windows Server® 2008 Enterprise"):

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

Vous devriez vraiment essayer d'éviter WMI pour une utilisation locale. C'est très pratique mais vous payez cher en termes de performances. C'est simple et rapide:

    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

Pourquoi ne pas utiliser Environment.OSVersion ? Il vous indiquera également de quelle manière il s’agit - Windows, Mac OS X, Unix, etc. Pour savoir si vous utilisez une version 64 bits ou 32 bits, utilisez IntPtr.Size - vous obtiendrez 4 octets pour 32 bits et 8 octets 64 bits.

21
configurator

Essayez: 

new ComputerInfo().OSVersion;

Sortie:  

Microsoft Windows 10 Entreprise

Remarque: Ajouter une référence à Microsoft.VisualBasic.Devices;

9
Niklas Peter

Exemple de sortie:

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

Classe d'échantillon:

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();
    }
}

Code source pour la classe OSInfo: http://www.csharp411.com/determine-windows-version-and-edition-with-c/ Cependant, le code contient une erreur. Vous devrez remplacer le " case 6 "(juste avant #endregion NAME) avec ceci:

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;

Et si vous voulez aller plus loin et voir si votre programme fonctionne en 64 ou 32 bits:

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

Une chose à laquelle il faut faire attention est que ces informations sont généralement localisées et rapportées différemment selon la langue du système d'exploitation. 

Vous pouvez obtenir beaucoup d’informations sur WMI recherchez le Win32_OperatingSystem class

3
JoshBerke

Notez que la question de l'architecture du processeur est complexe:

voulez-vous dire (les nombres les plus élevés exigent que les nombres les plus bas soient vrais):

  1. Le processeur est capable de gérer 64 bits (en ce sens qu'il prend en charge AMD/intel x64 ou Itanium)
  2. Le système d'exploitation est 64bit
    • Le GPR et les pointeurs sont en 64bits, c'est-à-dire XP 64, Vista 64, une version de serveur 64 bits ou un système d'exploitation 64 bits en mono
  3. Le processus en cours d'exécution est un processus 64 bits (ne s'exécutant pas sous Wow64 par exemple)

si vous êtes heureux que tous les 3 doivent être vrais alors 

IntPtr.Size == 8

Indique que les trois sont vrais

2
ShuggyCoUk

Un peu tard, mais c'est comme ça que je l'ai fait. Peut aider quelqu'un dans le futur. 

using Microsoft.Win32;

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

Je sais que ce n’est pas une réponse directe à la question et qu’il est aussi un peu tardif, mais pour ceux qui recherchent seulement un moyen de déterminer si le système d’exploitation est un client ou un serveur, il existe un moyen d’utiliser les éléments suivants: vous devez inclure la référence System.Management)

        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());
                }
            }
        }

tandis que la variable ProdType est un entier initialisé auparavant. Il contiendra une valeur comprise entre 1 et 3, tandis que 1 correspond à Workstation, 2 à Contrôleur de domaine et 3 à un serveur.

Ceci a été pris à partir de Accéder aux propriétés de Win32_OperatingSystem et a changé un peu ...

1
josibu

Vous pouvez utiliser les périphériques Visual Basic pour obtenir des informations sur la version.

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);

Sortie:  

6.1.7601.65536

Microsoft Windows 10 Entreprise

WinNT

Remarque: Vous devrez ajouter une référence à Microsoft.VisualBasic;

1
Suit Boy Apps

Divulgation: Après avoir posté ceci, j'ai réalisé que je dépendais d'une bibliothèque de méthodes d'extension Nuget appelée Z.ExntensionMethods qui contient 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));
}

Performances plus rapides 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));
}

exemple de sortie: 

Windows 7

Windows Server 2008

0
K. R.