Como determinar programaticamente se um determinado processo é de 32 ou 64 bits

Como meu aplicativo C # pode verificar se um determinado aplicativo / processo (observação: não o processo atual) está sendo executado no modo de 32 ou 64 bits?

Por exemplo, posso querer consultar um processo específico por nome, ou seja, 'abc.exe', ou com base no número de identificação do processo.

Uma das maneiras mais interessantes que vi é esta:

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

Para descobrir se OUTROS processos estão sendo executados no 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);
    }
}

Se você estiver usando .Net 4.0, é uma linha única para o processo atual:

Environment.Is64BitProcess

Consulte Environment.Is64BitProcessProperty (MSDN).

A resposta selecionada está incorreta porque não cumpre o que foi pedido. Ele verifica se um processo é um processo x86 em execução no sistema operacional x64; portanto, ele retornará "false" para um processo x64 no sistema operacional x64 ou processo x86 em execução no sistema operacional x86.
Além disso, ele não trata os erros corretamente.

Aqui está um método mais correto:

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

Você pode verificar o tamanho de um ponteiro para determinar se ele é 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;
}

Aqui está a verificação de uma linha.

bool is64Bit = IntPtr.Size == 8;

Eu gosto de usar isto:

string e = Environment.Is64BitOperatingSystem

Desta forma, se eu precisar localizar ou verificar um arquivo, posso escrever facilmente:

string e = Environment.Is64BitOperatingSystem

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

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