Come determinare a livello di programma se un particolare processo è a 32 bit o 64 bit

Question

Come può la mia applicazione C# controllare se una particolare applicazione/processo (nota: non il processo corrente) è in esecuzione in modalità a 32 o 64 bit ?

Per esempio, potrei voler interrogare un particolare processo per nome, cioè "abc.exe" o in base al numero ID del processo.

Answer 1

Uno dei modi più interessanti che ho visto è questo:

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

per verificare se altri processi sono in esecuzione in 64 bit emulatore (WOW64), utilizzare questo codice:

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

Answer 2

È possibile controllare la dimensione di un puntatore per determinare se è 32 bit o 64 bit.

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

Answer 3

Se stai usando .Net 4.0, si tratta di un one-liner per il processo in corso:

Environment.Is64BitProcess 

Vedi Environment.Is64BitProcessProperty (MSDN).

Answer 4

mi piace usare questo:

string e = Environment.Is64BitOperatingSystem 

In questo modo se ho bisogno di trovare o verificare un file che posso facilmente scrivere:

string e = Environment.Is64BitOperatingSystem 

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

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

Answer 5

Ecco il controllo di una riga.

bool is64Bit = IntPtr.Size == 8; 

Answer 6

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

Answer 7

La risposta selezionato non è corretto in quanto non fa quello che è stato chiesto. Controlla se un processo è un processo x86 eseguito su sistema operativo x64; quindi restituirà "false" per un processo x64 su un sistema x64 OS o x86 in esecuzione su un sistema operativo x86.
Inoltre, non gestisce correttamente gli errori.

Ecco un metodo più corretto:

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