Comment détecter une plateforme Windows 64 bits avec .NET?

Question

Dans une application C# .NET 2.0, j'utilise le code suivant pour détecter la plateforme du système d'exploitation :

string os_platform = System.Environment.OSVersion.Platform.ToString();

Cela renvoie "Win32NT". Le problème est que cela renvoie "Win32NT" même lorsqu'il est exécuté sur Windows Vista 64 bits.

Y a-t-il une autre méthode pour connaître la plateforme correcte (32 ou 64 bits) ?

Notez qu'il devrait également détecter 64 bits lorsqu'il est exécuté en tant qu'application 32 bits sur Windows 64 bits.

Answer 1

.NET 4 a deux nouvelles propriétés dans la classe Environment, Is64BitProcess et Is64BitOperatingSystem. Fait intéressant, si vous utilisez Reflector, vous pouvez voir qu'elles sont implémentées différemment dans les versions 32 bits et 64 bits de mscorlib. La version 32 bits renvoie false pour Is64BitProcess et appelle IsWow64Process via P/Invoke pour Is64BitOperatingSystem. La version 64 bits renvoie simplement true pour les deux.

Answer 2

MISE À JOUR : Comme Joel Coehoorn et d'autres le suggèrent, à partir de .NET Framework 4.0, vous pouvez simplement vérifier Environment.Is64BitOperatingSystem.

---

IntPtr.Size ne renverra pas la valeur correcte si vous exécutez .NET Framework 2.0 en 32 bits sur Windows 64 bits (il renverrait 32 bits).

Comme le décrit Raymond Chen de Microsoft, vous devez d'abord vérifier si vous exécutez un processus 64 bits (je pense qu'en .NET vous pouvez le faire en vérifiant IntPtr.Size), et si vous exécutez un processus 32 bits, vous devez quand même appeler la fonction Win API IsWow64Process. Si cela renvoie true, vous exécutez un processus 32 bits sur Windows 64 bits.

Raymond Chen de Microsoft : Comment détecter de manière programmable si vous exécutez Windows 64 bits

Ma solution :

static bool is64BitProcess = (IntPtr.Size == 8);
static bool is64BitOperatingSystem = is64BitProcess || InternalCheckIsWow64();

[DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool IsWow64Process(
    [In] IntPtr hProcess,
    [Out] out bool wow64Process
);

public static bool InternalCheckIsWow64()
{
    if ((Environment.OSVersion.Version.Major == 5 && Environment.OSVersion.Version.Minor >= 1) ||
        Environment.OSVersion.Version.Major >= 6)
    {
        using (Process p = Process.GetCurrentProcess())
        {
            bool retVal;
            if (!IsWow64Process(p.Handle, out retVal))
            {
                return false;
            }
            return retVal;
        }
    }
    else
    {
        return false;
    }
}

Answer 3

Si vous utilisez .NET Framework 4.0, c'est facile :

Environment.Is64BitOperatingSystem

Voir Propriété Environment.Is64BitOperatingSystem (MSDN).

Answer 4

Ceci est simplement une implémentation de ce qui est suggéré ci-dessus par Bruno Lopez, mais fonctionne sur Win2k + tous les service packs WinXP. Je me suis juste dit que je le posterais afin que d'autres personnes n'aient pas à le faire à la main. (j'aurais pu le poster en commentaire, mais je suis un nouvel utilisateur!)

[DllImport("kernel32", SetLastError = true, CallingConvention = CallingConvention.Winapi)]
public extern static IntPtr LoadLibrary(string libraryName);

[DllImport("kernel32", SetLastError = true, CallingConvention = CallingConvention.Winapi)]
public extern static IntPtr GetProcAddress(IntPtr hwnd, string procedureName);

private delegate bool IsWow64ProcessDelegate([In] IntPtr handle, [Out] out bool isWow64Process);

public static bool IsOS64Bit()
{
    if (IntPtr.Size == 8 || (IntPtr.Size == 4 && Is32BitProcessOn64BitProcessor()))
    {
        return true;
    }
    else
    {
        return false;
    }
}

private static IsWow64ProcessDelegate GetIsWow64ProcessDelegate()
{
  IntPtr handle = LoadLibrary("kernel32");

  if ( handle != IntPtr.Zero)
  {
    IntPtr fnPtr = GetProcAddress(handle, "IsWow64Process");

    if (fnPtr != IntPtr.Zero)
    {
      return (IsWow64ProcessDelegate)Marshal.GetDelegateForFunctionPointer((IntPtr)fnPtr, typeof(IsWow64ProcessDelegate));
    }
  }

  return null;
}

private static bool Is32BitProcessOn64BitProcessor()
{
  IsWow64ProcessDelegate fnDelegate = GetIsWow64ProcessDelegate();

  if (fnDelegate == null)
  {
    return false;
  }

  bool isWow64;
  bool retVal = fnDelegate.Invoke(Process.GetCurrentProcess().Handle, out isWow64);

  if (retVal == false)
  {
    return false;
  }

  return isWow64;
}

Answer 5

La réponse complète est la suivante (prise à la fois des réponses de stefan-mg, ripper234 et BobbyShaftoe):

    [DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool IsWow64Process([In] IntPtr hProcess, [Out] out bool lpSystemInfo);

    private bool Is64Bit()
    {
        if (IntPtr.Size == 8 || (IntPtr.Size == 4 && Is32BitProcessOn64BitProcessor()))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    private bool Is32BitProcessOn64BitProcessor()
    {
        bool retVal;

        IsWow64Process(Process.GetCurrentProcess().Handle, out retVal);

        return retVal;
    } 

Commencez par vérifier si vous êtes dans un processus 64 bits. Si ce n'est pas le cas, vérifiez si le processus 32 bits est un Wow64Process.