Cómo determinar mediante programación si un proceso en particular es de 32 bits o de 64 bits

¿Cómo puede mi aplicación C # verificar si una aplicación / proceso en particular (nota: no el proceso actual) se está ejecutando en modo de 32 bits o 64 bits?

Por ejemplo, es posible que desee consultar un proceso en particular por su nombre, es decir, 'abc.exe', o según el número de identificación del proceso.

Una de las formas más interesantes que he visto es esta:

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

Para saber si OTROS procesos se están ejecutando en el emulador de 64 bits (WOW64), use este código:

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 está utilizando .Net 4.0, es una sola línea para el proceso actual:

Environment.Is64BitProcess

Consulte Environment.Is64BitProcessProperty (MSDN).

La respuesta seleccionada es incorrecta ya que no hace lo que se le preguntó. Comprueba si un proceso es un proceso x86 que se ejecuta en el sistema operativo x64; por lo que devolverá "falso" para un proceso x64 en x64 OS o un proceso x86 que se ejecuta en x86 OS.
Además, no maneja los errores correctamente.

Aquí hay un método más correcto:

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

Puede verificar el tamaño de un puntero para determinar si es de 32 bits o de 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;
}

Aquí está la verificación de una línea.

bool is64Bit = IntPtr.Size == 8;

Me gusta usar esto:

string e = Environment.Is64BitOperatingSystem

De esta manera, si necesito ubicar o verificar un archivo, puedo escribir fácilmente:

string e = Environment.Is64BitOperatingSystem

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

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