x64 - 64 Bit betriebsystem erkennen
Hy@all,
kann man irgendwie ein 64 Bit Betriebsystem erkennen, egal ob Win XP oder Win Vista? Muss nämlich dementsprechend in der Registry nach anderen Einträgen suchen.
Methoden die ich schon habe:
abfragen, ob der Registryeintrag vorhanden ist -> HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node , hier weiß ich das dieser Node in Win XP x64 vorhanden ist, ist das in Win Vista x64 auch so?
über "System.Envionment.OSVersion" Versionsnummer raussuchen und bei z.B. Win XP schaun, ob die Version 5.2 (x64) statt Version 5.1 (x86)
Diese Methoden sind mir zu unsicher, kennt jemand eine bessere???
MfG
Tonka
Hallo,
auf die schnell fällt mir ein:
Nachschauen ob es den Folder "C:\Program Files (x86)" gibt. Den gibts nur auf x64 OS Versionen.
Hier gibts auch noch nen netten Thread drüber:
Grüsse,
egon
egrath's Blog: http://egonrath.eg.funpic.de/wordpress
Hy
Danke für deine Antwort, jedoch find ich es da noch bessere, den Registry Schlüssel abzufragen. Hast du Vista oder Xp oder Win 2000?
MfG
Tonka
Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE");
ldr
Hallo,
das mit dem Environment ist schon wesentlich besser. Hat leider einen kleinen Haken, der Text ist herstellerabhängig.
MfG
Tonka
Sammeln wir doch mal die möglichen Werte für dieses Feld ein:
PROCESSOR_ARCHITECTURE=x86
(Intel Core 2 Duo E4300, Windows XP 32-bit)
PS: Wer's nicht weiß, der Befehl "set" in der DOSe zeigt alle Variablen an. Im Dialog, der durch Drücken von Win+Pause erscheint, unter "Erweitert", "Umgebungsvariablen", kann man sie auch sehen.
PROCESSOR_ARCHITECTURE=x86
(Athlon 64 X2, Win XP 32-Bit)
Sieht für mich nicht sehr herstellerabhängig aus, eher microsoftabhängig ?
Hallo,
der Haken an der Sache ist, das ich die Variable "händisch" ändern kann. Ich habe einen INTEL drin und angezeigt wird wie oben genannt "AMD64".
MfG
Tonka
Ähm, geht nicht sowas wie sizeof(int) oder das gleiche als unmanaged type? Ich glaub ich hab da mal irgendwas gesehen... In .NET ist die Länge von int ja fest auf Int32 gesetzt, aber außerhalb von .NET müsste es doch einen Einfluss haben. Kann leider kein konkretes Codebeispiel geben.
Original von tonka
Hallo,der Haken an der Sache ist, das ich die Variable "händisch" ändern kann. Ich habe einen INTEL drin und angezeigt wird wie oben genannt "AMD64".
MfG
Tonka
So heißt die Technologie auch, nenn sie wie du willst AMD64, EM64T oder x86-64 ist doch eigentlich alles dasselbe.
ldr
Original von LonelyPixel
Ähm, geht nicht sowas wie sizeof(int) oder das gleiche als unmanaged type? Ich glaub ich hab da mal irgendwas gesehen... In .NET ist die Länge von int ja fest auf Int32 gesetzt, aber außerhalb von .NET müsste es doch einen Einfluss haben. Kann leider kein konkretes Codebeispiel geben.
Hallo,
ob Du auf x64 oder x86 unterwegs bist kannst Du feststellen indem Du einfach versuchst eine (mitgelieferte) 32-Bit DLL zu laden. Schlägt dies fehl befindest Du dich auf einer 64 Bit VM (32er DLL kann nicht in 64er Adressraum geladen werden).
Damit kannst Du aber nicht feststellen ob du auf der 32er VM eines 64er OS'es läufst.
Grüsse,
Egon
egrath's Blog: http://egonrath.eg.funpic.de/wordpress
OK, schon klar, aber als eindeutige Indentifikation kann die Umgebungsvariable nicht dienen, da der User (wenn er die Rechte besitzt) irgendwas in
PROCESSOR_ARCHITECTURE schreiben kann.
Ich werde eine Klasse bauen, in der mehrere Sachen kontrolliert werden.
1.) Registryeintrag "Wow6432Node" vorhanden -> wenn JA = x64 | wenn NEIN x86 (für mich die eindeutigste Abfrage, jedoch habe ich noch nicht geklärt, ob in Windows Vista dieser Knoten anders heißt oder x86-Programme anders in die Registry gespeichert werden!)
2.) wenn Umgebungsvariable "PROCESSOR_ARCHITECTURE" "64" enthält = x64 | wenn die Variable "86" enthält = x86
Die Abfrage über "C:\Program Files (x86)" erscheint mir nicht sinnvoll.
MfG
Tonka
Diesmal mit Code:
IntPtr.Size == 4 --> 32-bit-System
IntPtr.Size == 8 --> 64-bit-System
Der IntPtr-Typ ist als ganzzahliger Typ mit plattformabhängiger Größe konzipiert. Das heißt, dass es sich bei 32-Bit-Hardware und 32-Bit-Betriebssystemen i. d. R. um eine 32-Bit-Instanz dieses Typ handelt und bei 64-Bit-Hardware und 64-Bit-Betriebssystemen um eine 64-Bit-Instanz des Typs.
(Quelle: MSDN)
wmi --> Win32_OperatingSystem, könnte weiterhelfen!
ManagementClass mc = new ManagementClass("Win32_OperatingSystem");
foreach(ManagementObject o in mc.GetInstances()) {
if(o["Version"].ToString().StartsWith("5.2"))
Console.WriteLine("x64 (64bit)");
else
Console.WriteLine("x86 (32bit)");
}
ps: um das ganze nutzen zu können muss man unter Preferences-->Add Preferences -->.NET-->System.Management.dll hinzufügen
lg rizi
To rizi
Das habe ich schon gemacht. Geht aber über System.Environment noch leichter. Hier gibts die Variable OSVerion und hier kann man Major, ect. einzeln abrufen. Dazu muss ich von jedem Betriebsystem die Nummer kennen -> ist aufwendig, aber möglich.
To LonelyPixel
Das mit IntPtr erscheint mir als beste Lösung für das Problem. Ich werds einfach mal ausprobieren.
MfG
Tonka
Endlich haben wir die Lösung!
Die Lösung kam von "LonelyPixel ".
Das Problem war: Wie erkennen ich, welche Bit-Aritektur das Betriebsystem hat?
Lösung: IntPtr hat eine OS(-plattform) abhängige Größe - ist IntPtr.Size == 4 => 32 Bit , ist IntPtr.Size == 8 => 64 Bit
Hier eine kleine Klasse dazu:
using System;
using System.Collections.Generic;
using System.Text;
namespace OS
{
public enum architecture
{
unknown,
Bit32,
Bit64,
}
static class OSClass
{
public static architecture OSArchitecture
{
get
{
switch (IntPtr.Size)
{
case 4:
{
return architecture.Bit32;
}
case 8:
{
return architecture.Bit64;
}
default:
{
return architecture.unknown;
}
}
}
}
public static String OSArchitectureString
{
get
{
switch (IntPtr.Size)
{
case 4:
{
return "32 Bit";
}
case 8:
{
return "64 Bit";
}
default:
{
return "unknown";
}
}
}
}
public static Boolean Is32Bit
{
get{return IntPtr.Size == 4;}
}
public static Boolean Is64Bit
{
get{return IntPtr.Size == 8;}
}
}
}
Danke an euch alle, die am Erarbeiten dieser Lösung mitgearbeitet haben. DANKE
MfG
Tonka
(Sicher, dass es rizi war? 😉){darkgray}
PS: Ich würde ja eher sowas schreiben:
public static Boolean Is32Bit()
{
return IntPtr.Size == 4;
}
Oder so:
public static bool Is32Bit
{
get { return IntPtr.Size == 4; }
}
🙂
Hallo LonelyPixel!
tschuldige, war natürlich deine Lösung, hab mich da ein bisschen vertan.
Hab den Code schon geändert und gepostet.
MfG
Tonka
Hy@all
habe die Klasse ein bisschen geändert und erweitert. Neu ist jetzt, das die Betriebsystem-Version "eingedeutscht" wird z.B. 5.1 = Windows XP Prof. x86
using System;
using System.Collections.Generic;
using System.Text;
public enum architecture
{
unknown,
Bit32,
Bit64,
}
static class OS
{
public static class OS_Version
{
public static int Major
{
get { return Environment.OSVersion.Version.Major; }
}
public static short MajorRevision
{
get { return Environment.OSVersion.Version.MajorRevision; }
}
public static int Minor
{
get { return Environment.OSVersion.Version.Minor; }
}
public static short MinorRevision
{
get { return Environment.OSVersion.Version.MinorRevision; }
}
public static int Revision
{
get { return Environment.OSVersion.Version.Revision; }
}
public static int Build
{
get { return Environment.OSVersion.Version.Build; }
}
public static String ServicePack
{
get { return Environment.OSVersion.ServicePack; }
}
public static String OSString
{
get
{
String zw = "";
switch (Environment.OSVersion.Version.Major)
{
case 5:
{
zw = "Windows XP ";
switch (Environment.OSVersion.Version.Minor)
{
case 1:
{
zw = zw + "Professional x86 ";
} break;
case 2:
{
zw = zw + "Professional x64 Edition ";
} break;
default:
{
zw = zw + "unbekannt";
} break;
}
} break;
case 6:
{
zw = "Windows Vista ";
switch (Environment.OSVersion.Version.Minor)
{
default:
{
zw = zw + "unbekannt";
} break;
}
} break;
default:
{
zw = "unbekanntes Betriebsystem";
} break;
}
return zw;
}
}
}
public static architecture OSArchitecture
{
get
{
switch (IntPtr.Size)
{
case 4:
{
return architecture.Bit32;
}
case 8:
{
return architecture.Bit64;
}
default:
{
return architecture.unknown;
}
}
}
}
public static String OSArchitectureString
{
get
{
switch (IntPtr.Size)
{
case 4:
{
return "32 Bit";
}
case 8:
{
return "64 Bit";
}
default:
{
return "unknown";
}
}
}
}
public static Boolean Is32Bit
{
get{return IntPtr.Size == 4;}
}
public static Boolean Is64Bit
{
get{return IntPtr.Size == 8;}
}
}
Was ich noch nicht weiß ist, welche ID hat Win XP home (5.0 ????). Wie schauts bei Vista aus?
MfG
Tonka
Hallo,
Windows XP Home hat auch OS Version 5.1
Vista hat 6.0
Grüsse,
Egon
egrath's Blog: http://egonrath.eg.funpic.de/wordpress
Hallo
Wie unterscheide ich dann zwischen Win Xp Prof und Home, wenn beide 5.1 haben. Wie schauts bei Vista aus, gibt ja 5 Versionen?
MfG
Tonka
Hier hab ich schon ne umfangreichere Liste drin, kannst du nachschauen:
http://beta.unclassified.de/code/dotnet/osdetect/
Die einzelnen Editionen wie Std/Home/Pro/MCE/Tablet/Business/Ultimate haben keine Auswirkung auf die Version des Systems selbst sondern enthalten nur zusätzliche Funktionen.