web-dev-qa-db-fra.com

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 (remarque: ce n'est pas le processus actuel) s'exécute en mode 32 bits ou 64 bits? 

Par exemple, je souhaiterais peut-être interroger un processus particulier par son nom, c'est-à-dire "abc.exe" ou en fonction du numéro d'identification du processus.

c#process32bit-64bit
90
satya

Une des manières 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 d'autres processus sont en cours d'exécution 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);
    }
}
166
Jesse C. Slicer

Si vous utilisez .Net 4.0, c'est un processus unique pour le processus actuel:

Environment.Is64BitProcess

Voir Environment.Is64BitProcessProperty (MSDN).

133
Sam

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 s'exécutant sur un système d'exploitation x64; il retournera donc "false" pour un processus x64 sur un système d'exploitation x64 ou x86 exécuté sur un système d'exploitation x86.
En outre, il ne gère pas les erreurs correctement. 

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);
}
14
user626528

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

int bits = IntPtr.Size * 8;
Console.WriteLine( "{0}-bit", bits );
Console.ReadLine();
10
Darwyn
[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;
}
4
Praveen M B

Voici la vérification d'une ligne.

bool is64Bit = IntPtr.Size == 8;
1
Vikram Bose

J'aime utiliser ceci: 

string e = Environment.Is64BitOperatingSystem

Ainsi, si je dois localiser ou 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\";
0
user1351333