64 Bit oder 32 Bit Prozessor?

Hallo Gemeinde,

um herauszufinden ob ein Benutzer einen 64Bit oder einen 32Bit Prozessor bzw. Betriebssystem hat, verwende ich folgenden Code:

                string pa = Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE");
                string dir = "x" + ((String.IsNullOrEmpty(pa) || String.Compare(pa, 0, "x86", 0, 3, true) == 0) ? 86 : 64);

Nur leider funktioniert der nicht, denn er meint ich hätte einen 32Bit Prozessor, obwohl ich einen 64 Bit habe.

Wenn ich die Kommandozeile aufrufe und dort die Umgebungsvariable "PROCESSOR_ARCHITECTURE" auslese, wird korrekterweise PROCESSOR_ARCHITECTURE=AMD64 ausgegeben. Wenn ich mir die variable "pa" ausgeben lasse im Debugger, steht aber "x86" drin. Nun wollte ich fragen wo der Fehler ist, oder ob jemand eine andere Möglichkeit hat um zu schauen ob ein Benutzer mit 64 oder 32 Bit unterwegs ist.

MfG TripleX

Evtl. so was in der Art:

using System;
using System.Runtime.InteropServices;

class SystemCheck
{
    static bool Is64Bit
    {
        get { return Marshal.SizeOf(typeof(IntPtr)) == 8; }
    }
}

s.

Also ich habs bei mir mal mit WMI versucht. Gibt da ein ganz nettes tool von microsoft, den "WMI Code Generator" der generiert dir code um bestimme PC Informationen auszulesen. Um die architektur auszulesen hat er mir folgendes ausgegeben:

using System;
using System.Management;
using System.Windows.Forms;
public class MyWMIQuery
{
public static void Main()
{
try
{
ManagementObjectSearcher searcher =
new ManagementObjectSearcher("root\\CIMV2",
"SELECT * FROM Win32_Processor";);

foreach (ManagementObject queryObj in searcher.Get())
{
Console.WriteLine("-----------------------------------";);
Console.WriteLine("Win32_Processor instance";);
Console.WriteLine("-----------------------------------";);
Console.WriteLine("Architecture: {0}", queryObj["Architecture"]);
}
}
catch (ManagementException e)
{
MessageBox.Show("An error occurred while querying for WMI data: " + e.Message);
}
}
}

queryObj["Architecture"] ist hier allerdings ein ushort zwischen 0 und 9 und laut msdn hat diese folgende bedeutung:

(0x0) x86
(0x1) MIPS
2 (0x2) Alpha
3 (0x3) PowerPC
6 (0x6) Intel Itanium Processor Family (IPF)
9 (0x9) x64

Info: Bei mir hat diese methode korrekterweise 9 ausgegeben

EDIT: Wegen deinem Problem das es falsch angezeigt wird, überprüf mal was du bei den Projekteigenschaften bei release und im debug mode als zielplattform eingestellt hast. Habs jetzt nciht überprüft könnte aber damit zusammenhängen

Evtl. so was in der Art: ...

funktioniert auch nicht, bei folgendem Code gibt er mit für dir=x86:

string dir = "x" + (Marshal.SizeOf(typeof(IntPtr)) == 8 ? 64 : 86);

EDIT: Wegen deinem Problem das es falsch angezeigt wird, überprüf mal was du bei den Projekteigenschaften bei release und im debug mode als zielplattform eingestellt hast. Habs jetzt nciht überprüft könnte aber damit zusammenhängen

jo das wars ... danke dir 😃

suche mal im registry-schlüssel
HKEY_LOCAL_MACHINE\HARDWARE\DESCRIPTION\System\CentralProcessor\0

key heisst
Identifier

wenn sein wert enthält x86 dann hast du 32 bits, ansonsten ist es eine 64 bit maschine

So ein ähnliches Problem hatte ich auch.

Unterscheiden muss man :

• 32 / 64 bit Prozessor
• 32 / 64 Bit Betriebssystem
• 32 / 64 Bit Anwendung

So kann auf einem 64-Bit-Prozessor natürlich ein 32-Bit-Betriebssystem laufen, und auf einem 64-Bit-Betriebssystem kann auch eine 32-Bit-Anwendung laufen.

Ich wollte feststellen ob mein Programm auf einem 32- oder 64-Bit-Betriebssystem läuft. Da mein Programm als X86 kompiliert ist (ich verwende einige 32-bit-DLL's) haben alle Tipps aus Goggel nicht geholfen, z.B. WMI, Pointerlänge etc.

Ich mache das jetzt so :

public bool Is64Bit()
{
	return (Environment.GetEnvironmentVariable("ProgramFiles(x86)") != "");
}

😉

Grüße Bernd

PS.: Bisher nur auf Windows 7 64 bit getestet. Kann das man jemand auf Vista 64 bit und XP 64 bit prüfen ? Einfach "set pro" in der Dos-Box eingeben.

@BerndFfm:
Schau dir mal die IsWow64Process Funktion an.

Hi TripleX,

zuerst mal die Frage, wozu du das wissen willst, du machst damit dann irgendwas mit einer "dir" Variable...mir nicht ganz klar.

Zur Vorgehensweise (in Anlehnung an Bernds Klassifikation):
32 / 64 bit Prozessor
Dafür die WMI-Abfrage mit der Architecture verwenden.
Die Registry-Lösung finde ich persönlich nicht so schön wie per WMI.

32 / 64 bit Anwendung
Der Weg um herauszufinden, ob die Applikation mit 32/64-Bit läuft, ist mittels der Größe von IntPtr. Allerdings musst du dafür nicht extra Marshal.SizeOf befragen.
Denn IntPtr hat dafür extra das IntPtr.Size-Property.
Das ist entweder 4 oder 8.

32 / 64 Bit Betriebssystem
Wenn die Anwendung 64-Bit ist, dann muss das OS auch 64Bit sein.
Allerdings kann bei einer 32Bit-Anwendung das OS noch beides sein.
Die Möglichkeit, einer 32Bit Anwendung auf einem 64Bit-Windows laufen zu lassen, wird über eine Technik namens WOW64 (Windows On Windows64) ermöglicht.
Und ob dies gerade der Fall ist, kann man abfragen mit IsWow64Process. Auf der PInvoke.net Seite gibts natürlich auch dafür schon einen Eintrag über IsWow64Process.
Und so weiß man auch, ob man auf 32 oder 64 Windows läuft.

beste Grüße
zommi

Danke Marsgk und Zommi, werde ich gleich mal probieren.

Grüße Bernd

Im .NET 4.0 gibt es eine neue Eigenschaft Is64BitOperationSystem. Zu finden in der Environment-Klasse. Der Code dazu sieht wie folgt aus:

public static bool Is64BitOperatingSystem
{
    [SecuritySafeCritical]
    get
    {
        bool flag;
        return ((Win32Native.DoesWin32MethodExist("kernel32.dll", "IsWow64Process") && Win32Native.IsWow64Process(Win32Native.GetCurrentProcess(), out flag)) && flag);
    }
}

Kurz erklärt:
In der Methode wird die kernel32.dll geöffnet und nachgeschaut, ob überhaupt die exportierte Funktion "IsWow64Process" existiert. Nur wenn das der Fall ist, wird auch diese Methode aufgerufen. Das hat folgenden Grund: Die Methode IsWow64Process kann natürlich nicht auf einem 32bit System aufgerufen werden, da es sonst sofort knallt. Die gibts halt nicht.

Mein Code sieht nun so aus :

[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 bool IsWow64()
{
	Process p = Process.GetCurrentProcess();
	IntPtr handle = p.Handle;
	bool isWow64;
	bool success = IsWow64Process(handle, out isWow64);
	if (!success)
		return false;
	else
		return isWow64; 
}

Andere Beispiele aus dem Internet haben bei mir nicht funktioniert, vielleicht weil ich noch .NET 2.0 einsetze.

Zu den Umgebungsvariablen bei einem Wow64 Prozess : http://msdn.microsoft.com/en-us/library/aa384274(VS.85).aspx

Da diese erst mit Windows 7 eingeführt wurden hätte mein erstes Beispiel nicht unter Vista und XP funktioniert.

Grüße Bernd

In der Methode wird die kernel32.dll geöffnet und nachgeschaut, ob überhaupt die exportierte Funktion "IsWow64Process" existiert. Nur wenn das der Fall ist, wird auch diese Methode aufgerufen. Das hat folgenden Grund: Die Methode IsWow64Process kann natürlich nicht auf einem 32bit System aufgerufen werden, da es sonst sofort knallt. Die gibts halt nicht.

IsWow64Process gibt es sehr wohl auch auf 32-Bit Betriebssystemen und liefert hier erwartungsgemäß false zurück. Allerdings gibt es IsWow64Process erst seit Windows XP SP2, deshalb die Überprüfung analog zum Beispielcode der MSDN zu IsWow64Process.
Da es Is64BitOperationSystem erst mit .Net 4.0 gibt, und dieses zumindest Windows XP SP3 voraussetzt ist diese Überprüfung eigentlich nicht nötig.