Comment déterminer par programmation si un processus est en 32 bits ou 64 bits

Comment mon application C# vérifier si une application particulière/processus (remarque: le processus actuel) est en cours d'exécution en 32-bit ou 64-bit de mode?

Par exemple, je pourrais avoir besoin d'interroger un processus particulier par nom, j'.e, 'abc.exe' ou basé sur le numéro d'ID de processus.

Veuillez toujours mettre la langue dans une balise; je vais changer de maintenant sur ce post. 🙂
Veuillez préciser si vous voulez savoir les actuelle processus est de 64 bits ou vous interrogez un autre processus?
Dupelicate: stackoverflow.com/questions/266082/...

InformationsquelleAutor satya | 2009-12-23

32bit-64bit c#process

173

L'un des plus intéressant que j'ai vu est: est-ce
```
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 le 64-bit émulateur (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);
}
}
```
- Salut, ce sera le travail de l'instance en cours. mais je veux savoir pour certains autres processus qui est déjà en cours d'exécution. Aider Pls
- Je suis modifiant cette réponse maintenant.
- (Environment.OSVersion.Version.Major >= 5 && Environment.OSVersion.Version.Minor >= 1) Et c'est pourquoi Microsoft a pour créer la version mensonge compatibilité des cales - pour contourner les bugs dans le code comme ça. Ce qui se passe lorsque Windows Vista (6.0) qui vient de sortir? Et puis les gens mauvais de la bouche de Microsoft pour Windows 7 version 6.1 plutôt que de 7.0, il corrige donc beaucoup de app-compat bugs.
- l' [Out] hors bool wow64Process devrait être [Out] hors Int32 wow64Process parce que le natif de la fonction BOOL cartes à Int32
- pas de. C'est un pointeur vers une valeur de type boolean. La source de référence: msdn.microsoft.com/en-us/library/ms684139
- Nom de la fonction IsWin64 est un peu trompeur, je pense. Elle renvoie true si les processus 32 bits s'exécute sous le système d'exploitation x64.
- Pourquoi utiliser processHandle = Process.GetProcessById(process.Id).Handle; au lieu de simplement processHandle = process.Handle; ?
- bien n'est-ce pas juste une bonne question. Je n'ai aucune idée. Il doit avoir été vestige d'une commutation autour de faire les choses une à l'autre. Merci de trouver que!
- Cette réponse est tout simplement faux; et en renvoyant false au lieu de lever une exception en cas d'erreur est une très mauvaise conception.
- Il est utilisé uniquement pour système 64 bits.Cette logique de l'échec dans le Système 32 Bits
InformationsquelleAutor Jesse C. Slicer
137

Si vous êtes en utilisant .Net 4.0, c'est un one-liner pour le processus en cours:
```
Environment.Is64BitProcess
```
Voir De l'environnement.Is64BitProcessProperty (MSDN).
- Pourriez-vous poster le code de Is64BitProcess? Peut-être que je peux utiliser ce qu'il fait, de savoir si je suis en cours d'exécution dans un processus 64 bits.
- Je doute que Sam soit légalement autorisé à poster MME code sur ce forum. Je ne suis pas sûr de la teneur exacte de leur licence, mais je suis assez sûr il interdit la reproduction du code n'importe où.
- quelqu'un a fait ce travail pour vous: stackoverflow.com/questions/336633/...
- L'OP spécifiquement demandé à la requête de l'autre processus, et non pas le processus en cours.
- Notez que Microsoft ne poste le code pour Is64BitProcess ( referencesource.microsoft.com/#mscorlib/system/environment.cs). Cependant, c'est juste un retour codée en dur relevé, contrôlée par le symbole de compilation.
InformationsquelleAutor Sam

La réponse sélectionnée est incorrecte car elle ne permet pas de faire ce qui était demandé. Il vérifie si un processus est un x86 processus en cours d'exécution sur le système d'exploitation x64, au lieu; de sorte qu'il sera de retour "faux" pour un x64 processus sur le système d'exploitation x64 ou x86 processus en cours d'exécution sur x86 OS.

Aussi, il ne gère pas les erreurs correctement.

Ici est un bonne méthode:

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

Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE") == "x86" retourne toujours vrai pour un processus 32 bits. Mieux utiliser System.Environment.Is64BitOperatingSystem si .NET4 est pris en charge
Suhardi, ok merci.

InformationsquelleAutor user626528

10

Vous pouvez vérifier la taille d'un pointeur pour déterminer s'il est 32bits ou 64bits.
```
int bits = IntPtr.Size * 8;
Console.WriteLine( "{0}-bit", bits );
Console.ReadLine();
```
- Au moment de cette réponse a d'abord été posté il n'était pas très clair, mais l'OP voulait savoir comment requête l'autre processus plutôt que sur les processus en cours.
InformationsquelleAutor 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;
}

L'OP spécifiquement demandé comment requête l'autre processus, et non pas le processus en cours.

InformationsquelleAutor Praveen M B

1

Ici est celui de la vérification.
```
bool is64Bit = IntPtr.Size == 8;
```
- L'OP spécifiquement demandé comment requête l'autre processus, et non pas le processus en cours.
InformationsquelleAutor Vikram Bose
0

J'aime utiliser ce:
```
string e = Environment.Is64BitOperatingSystem
```
De cette façon si j'ai besoin de trouver ou vérifier un fichier que 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\";
```
- que sur les processus 32 bits en 64 bits de l'OS de la Machine ?
- En supposant que la lettre de lecteur semble mal que de bien
- Est-il vraiment si difficile à utiliser Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86) au lieu de coder en dur `C:\Program les Fichiers"?
- Jamais coder en dur "program files", parce que c'est une chaîne localizable. Αρχεία Εφαρμογών, Arquivos de Programas, etc.
InformationsquelleAutor user1351333

Vous devez vous connecter pour publier un commentaire.