Comment déterminer par programme si un processus particulier est 32 bits ou 64 bits

Comment mon application C # peut-elle vérifier si une application / un processus particulier (note: pas le processus actuel) s'exécute en mode 32 bits ou 64 bits?

Par exemple, je pourrais vouloir interroger un processus particulier par son nom, c'est-à-dire «abc.exe», ou en fonction du numéro d'identification du processus.

L'une des façons les plus intéressantes que j'ai vues est la suivante:

if (IntPtr.Size == 4)
{
    // 32-bit
}
else if (IntPtr.Size == 8)
{
    // 64-bit
}
else
{
    // The future is now!
}

Pour savoir si AUTRES processus s'exécutent dans l'émulateur 64 bits (WOW64), utilisez ce code:

namespace Is64Bit
{
    using System;
    using System.ComponentModel;
    using System.Diagnostics;
    using System.Runtime.InteropServices;

    internal static class Program
    {
        private static void Main()
        {
            foreach (var p in Process.GetProcesses())
            {
                try
                {
                    Console.WriteLine(p.ProcessName + " is " + (p.IsWin64Emulator() ? string.Empty : "not ") + "32-bit");
                }
                catch (Win32Exception ex)
                {
                    if (ex.NativeErrorCode != 0x00000005)
                    {
                        throw;
                    }
                }
            }

            Console.ReadLine();
        }

        private static bool IsWin64Emulator(this Process process)
        {
            if ((Environment.OSVersion.Version.Major > 5)
                || ((Environment.OSVersion.Version.Major == 5) && (Environment.OSVersion.Version.Minor >= 1)))
            {
                bool retVal;

                return NativeMethods.IsWow64Process(process.Handle, out retVal) && retVal;
            }

            return false; // not on 64-bit Windows Emulator
        }
    }

    internal static class NativeMethods
    {
        [DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)]
        [return: MarshalAs(UnmanagedType.Bool)]
        internal static extern bool IsWow64Process([In] IntPtr process, [Out] out bool wow64Process);
    }
}

Si vous utilisez .Net 4.0, il s'agit d'une ligne unique pour le processus actuel:

Environment.Is64BitProcess

Voir Environment.Is64BitProcessProperty (MSDN).

La réponse sélectionnée est incorrecte car elle ne fait pas ce qui a été demandé. Il vérifie si un processus est un processus x86 exécuté sur un système d'exploitation x64 à la place; il retournera donc "false" pour un processus x64 sur un système d'exploitation x64 ou un processus x86 fonctionnant sur un système d'exploitation x86.
En outre, il ne gère pas correctement les erreurs.

Voici une méthode plus correcte:

internal static class NativeMethods
{
    // see https://msdn.microsoft.com/en-us/library/windows/desktop/ms684139%28v=vs.85%29.aspx
    public static bool Is64Bit(Process process)
    {
        if (!Environment.Is64BitOperatingSystem)
            return false;
        // if this method is not available in your version of .NET, use GetNativeSystemInfo via P/Invoke instead

        bool isWow64;
        if (!IsWow64Process(process.Handle, out isWow64))
            throw new Win32Exception();
        return !isWow64;
    }

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

Vous pouvez vérifier la taille d'un pointeur pour déterminer s'il s'agit de 32 bits ou 64 bits.

int bits = IntPtr.Size * 8;
Console.WriteLine( "{0}-bit", bits );
Console.ReadLine();

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

public static bool Is64Bit()
{
    bool retVal;

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

    return retVal;
}

Voici la vérification en une ligne.

bool is64Bit = IntPtr.Size == 8;

J'aime utiliser ceci:

string e = Environment.Is64BitOperatingSystem

De cette façon, si j'ai besoin de localiser ou de vérifier un fichier, je peux facilement écrire:

string e = Environment.Is64BitOperatingSystem

       // If 64 bit locate the 32 bit folder
       ? @"C:\Program Files (x86)\"

       // Else 32 bit
       : @"C:\Program Files\";