Erkennen, ob aktuelle Windows-Version 32-Bit oder 64-Bit

Question

Ob Sie es glauben oder nicht, mein Installer ist so alt, dass es keine Möglichkeit hat, die 64-Bit-Version von Windows zu erkennen.

Gibt es einen Windows-DLL-Aufruf oder (noch besser) eine Umgebungsvariable, die diese Informationen für Windows XP und Windows Vista geben würde?

Eine mögliche Lösung

Ich sehe, dass Wikipedia heißt es, dass die 64-Bit-Version von Windows XP und Windows Vista eine einzigartige Umgebungsvariable haben: %ProgramW6432%, so vermute ich, dass auf 32-Bit-Windows leer sein würde

.

Diese Variable auf Program Files Verzeichnis, das alle installierten Programm von Windows und anderen speichert. Der Standard auf englischsprachigen Systemen ist C:\Program Files. In 64-Bit-Versionen von Windows (XP, 2003, Vista), gibt es %ProgramFiles(x86)% auch die standardmäßig und C:\Program Files (x86) auf %ProgramW6432%, die standardmäßig auf C:\Program Files. Die %ProgramFiles% selbst hängt davon ab, ob der Prozess die Umgebungsvariable anfordernden selbst 32-Bit- oder 64-Bit (das von Windows auf dem Windows 64-Bit-Umleitung verursacht wird).

Answer 1

Siehe Batch-Skript aufgeführt in Wie überprüfen, ob Computer A 32 ausgeführt wird Bit oder 64-Bit-Betriebssystem . Es enthält auch Anweisungen für die von der Registry überprüft:

Sie können die folgenden Registrierungsschlüssel verwenden, um zu überprüfen, ob Computer 32 oder 64-Bit-Windows-Betriebssystem ausgeführt wird:

HKLM\HARDWARE\DESCRIPTION\System\CentralProcessor\0

Sie werden die folgenden Registrierungseinträge im rechten Bereich sehen:

Identifier     REG_SZ             x86 Family 6 Model 14 Stepping 12
Platform ID    REG_DWORD          0x00000020(32)

Das oben gezeigte „x86“ und „0x00000020 (32)“ anzuzeigen, dass die Betriebssystemversion ist 32 Bit.

Answer 2

Um zu überprüfen, für eine 64-Bit-Version von Windows in einer Eingabefeld, verwende ich die folgende Vorlage:

test.bat:

@echo off
if defined ProgramFiles(x86) (
    @echo yes
    @echo Some 64-bit work
) else (
    @echo no
    @echo Some 32-bit work
)

ProgramFiles(x86) ist eine Umgebungsvariable automatisch von cmd.exe definiert (beide 32-Bit und 64-Bit-Versionen) auf Windows 64-Bit-Maschinen nur.

Answer 3

Hier finden Sie einige Delphi-Code zu überprüfen, ob Ihr Programm auf einem 64-Bit-Betriebssystem ausgeführt wird:

function Is64BitOS: Boolean;
{$IFNDEF WIN64}
type
  TIsWow64Process = function(Handle:THandle; var IsWow64 : BOOL) : BOOL; stdcall;
var
  hKernel32 : Integer;
  IsWow64Process : TIsWow64Process;
  IsWow64 : BOOL;
{$ENDIF}
begin
  {$IFDEF WIN64}
     //We're a 64-bit application; obviously we're running on 64-bit Windows.
     Result := True;
  {$ELSE}
  // We can check if the operating system is 64-bit by checking whether
  // we are running under Wow64 (we are 32-bit code). We must check if this
  // function is implemented before we call it, because some older 32-bit 
  // versions of kernel32.dll (eg. Windows 2000) don't know about it.
  // See "IsWow64Process", http://msdn.microsoft.com/en-us/library/ms684139.aspx
  Result := False;
  hKernel32 := LoadLibrary('kernel32.dll');
  if hKernel32 = 0 then RaiseLastOSError;
  try
    @IsWow64Process := GetProcAddress(hkernel32, 'IsWow64Process');
    if Assigned(IsWow64Process) then begin
      if (IsWow64Process(GetCurrentProcess, IsWow64)) then begin
        Result := IsWow64;
      end
      else RaiseLastOSError;
    end;
  finally
    FreeLibrary(hKernel32);
  end;  
  {$ENDIf}
end;

Answer 4

Getestet habe ich die Lösung, die ich in meiner Frage vorgeschlagen:

Getestet für Windows-Umgebungsvariable: ProgramW6432

Wenn es nicht leer ist, dann ist es 64-Bit-Windows.W

Answer 5

Von einer Batch-Skript:

IF PROCESSOR_ARCHITECTURE == x86 AND
   PROCESSOR_ARCHITEW6432 NOT DEFINED THEN
   // OS is 32bit
ELSE
   // OS is 64bit
END IF

Verwenden von Windows API :

if (GetSystemWow64Directory(Directory, MaxDirectory) > 0) 
   // OS is 64bit
else
   // OS is 32bit

Quellen:

1. 's gemacht: ermitteln Prozess Bitness
2. GetSystemWow64Directory Funktion

Answer 6

Wenn Sie API-Aufrufe machen können, versuchen Sie es mit GetProcAddress / < a href = "http://msdn2.microsoft.com/en-us/library/ms683199.aspx" rel = "noreferrer"> GetModuleHandle für die Existenz von IsWow64Process , die nur in Windows-Betriebssystem ist die 64-Bit-Versionen haben.

Sie können auch die versuchen Programfiles (x86) Umgebungsvariable in Vista / 2008 für die Abwärtskompatibilität verwendet, aber ich bin nicht 100% sicher XP-64 oder 2003-64.

Viel Glück!

Answer 7

Ich habe diese in einer Login-Skript 64-Bit-Windows-Erkennung

, wenn "% ProgramW6432%" == "% Programfiles%" goto is64flag

Answer 8

Für ein VBScript / WMI one-Liner, der die Bits Actuals Zahl (32 oder 64) des Betriebssystems oder der Hardware abruft, einen Blick auf http://csi-windows.com/toolkit/csi-getosbits

Answer 9

Ich weiß nicht, welche Sprache Sie verwenden, aber .NET hat die Umgebungsvariable PROCESSOR_ARCHITEW6432, wenn das Betriebssystem 64-Bit.

Wenn alles, was Sie wissen wollen, ist, ob die Anwendung ausgeführt wird 32-Bit oder 64-Bit, können Sie IntPtr.Size überprüfen. Es wird 4 sein, wenn in 32-Bit-Modus und 8, wenn in 64-Bit-Modus ausgeführt wird.

Answer 10

Ich möchte hinzufügen, was ich in Shell-Skripten verwenden (kann aber leicht in jeder Sprache verwendet werden) hier. Der Grund ist, dass einige der hier Lösungen keine WoW64 arbeiten, verwenden manche Dinge nicht wirklich für das bedeutete (Überprüfung, ob es einen * (x86) Ordner ist) oder funktionieren nicht in cmd-Skripten. Ich fühle mich, das ist der „richtige“ Weg, es zu tun, und soll sicher sein, auch in zukünftigen Versionen von Windows.

 @echo off
 if /i %processor_architecture%==AMD64 GOTO AMD64
 if /i %PROCESSOR_ARCHITEW6432%==AMD64 GOTO AMD64
    rem only defined in WoW64 processes
 if /i %processor_architecture%==x86 GOTO x86
 GOTO ERR
 :AMD64
    rem do amd64 stuff
 GOTO EXEC
 :x86
    rem do x86 stuff
 GOTO EXEC
 :EXEC
    rem do arch independent stuff
 GOTO END
 :ERR
    rem I feel there should always be a proper error-path!
    @echo Unsupported architecture!
    pause
 :END

Answer 11

Eine Menge Antworten erwähnt Aufruf IsWoW64Process() oder verwandte Funktionen. Dies ist nicht die richtig Art und Weise. Sie sollten GetNativeSystemInfo() verwendet werden, die für diesen Zweck entwickelt wurde. Hier ein Beispiel:

SYSTEM_INFO info;
GetNativeSystemInfo(&info);

if (info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) {
  // It's a 64-bit OS
}

Siehe auch: https://msdn.microsoft .com / de-de / library / windows / Desktop / ms724340% 28v = VS.85% 29.aspx

Answer 12

Ich weiß nicht, auf dem Windows-Version vorhanden, aber unter Windows Vista und später diese lautet:

Function Is64Bit As Boolean
    Dim x64 As Boolean = System.Environment.Is64BitOperatingSystem
    If x64 Then
       Return true
    Else
       Return false
    End If
End Function

Answer 13

In C #:

public bool Is64bit() {
    return Marshal.SizeOf(typeof(IntPtr)) == 8;
}

VB.NET :

Public Function Is64bit() As Boolean
   If Marshal.SizeOf(GetType(IntPtr)) = 8 Then Return True
   Return False
End Function

Answer 14

Ich benutze diese:

@echo off
if "%PROCESSOR_ARCHITECTURE%"=="AMD64" (
 echo 64 BIT
) else (
 echo 32 BIT
)

Es funktioniert unter Windows XP, getestet auf Windows XP Professional Beide 64-Bit und 32-Bit.

Answer 15

Ich weiß, das ist alt, aber hier ist es, was ich Win764 erkennen

On Error Resume Next

Set objWSHShell = CreateObject("WScript.Shell")

strWinVer = objWSHShell.RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\BuildLabEx")

If len(strWinVer) > 0 Then
    arrWinVer = Split(strWinVer,".")
    strWinVer = arrWinVer(2)
End If

Select Case strWinVer
Case "x86fre"
strWinVer = "Win7"
Case "amd64fre"
    strWinVer = "Win7 64-bit"
Case Else
    objWSHShell.Popup("OS Not Recognized")
    WScript.Quit
End Select

Answer 16

testete ich die folgende Batchdatei auf Windows 7 x64 / x86 und Windows XP x86 und es ist in Ordnung, aber ich habe nicht Windows XP x64 noch versucht, aber das wird wahrscheinlich funktionieren:

If Defined ProgramW6432 (Do x64 stuff or end if you are aiming for x86) else (Do x86 stuff or end if you are aiming for x64) 

Answer 17

Verwenden von Windows Powershell, wenn der folgende Ausdruck true zurückgibt, dann ist es ein 64-Bit-Betriebssystem:

(([Array](Get-WmiObject -Class Win32_Processor | Select-Object AddressWidth))[0].AddressWidth -eq 64)

Dieses wurde genommen und modifiziert aus: http: / /depsharee.blogspot.com/2011/06/how-do-detect-operating-system.html (Methode # 3). Ich habe dies auf Win7 64 Bit getestet (in beiden 32 und 64-Bit-Powershell-Sitzungen) und XP 32 Bit.

Answer 18

Der beste Weg ist sicherlich nur zu prüfen, ob es zwei Programmdateien Verzeichnisse, ‚Program Files'and‚Program Files (x86)‘ Der Vorteil dieser Methode ist, dass Sie es tun können, wenn die o / s ist zum Beispiel nicht ausgeführt wird, wenn die Maschine kann nicht gestartet werden und Sie mögen das Betriebssystem neu zu installieren

Answer 19

Interessanterweise, wenn ich

get-wmiobject -class Win32_Environment -filter "Name='PROCESSOR_ARCHITECTURE'"

Ich bekomme AMD64 in 32-Bit- und 64-Bit-ISE (auf Win7 64 Bit).

Answer 20

Eine weitere Möglichkeit, von Egerman erstellt, die PE verwendet Zahlen kompilierten ausführbaren Dateien (verlässt sich nicht auf Registry-Einträge oder Umgebungsvariablen):

@echo off &setlocal


call :getPETarget "%SystemRoot%\explorer.exe"


if "%=ExitCode%" EQU "00008664" (
    echo x64
) else (
    if "%=ExitCode%" EQU "0000014C" (
        echo x32
    ) else (
        echo undefined
    )
)


goto :eof


:getPETarget FilePath
:: ~~~~~~~~~~~~~~~~~~~~~~
:: Errorlevel
::   0 Success
::   1 File Not Found
::   2 Wrong Magic Number
::   3 Out Of Scope
::   4 No PE File
:: ~~~~~~~~~~~~~~~~~~~~~~
:: =ExitCode
::   CPU identifier

setlocal DisableDelayedExpansion
set "File=%~1"
set Cmp="%temp%\%random%.%random%.1KB"
set Dmp="%temp%\%random%.%random%.dmp"

REM write 1024 times 'A' into a temporary file
if exist "%File%" (
  >%Cmp% (
    for /l %%i in (1 1 32) do <nul set /p "=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  )
  setlocal EnableDelayedExpansion
) else (endlocal &cmd /c exit 0 &exit /b 1)

REM generate a HEX dump of the executable file (first 1024 Bytes)
set "X=1"
>!Dmp! (
  for /f "skip=1 tokens=1,2 delims=: " %%i in ('fc /b "!File!" !Cmp!^|findstr /vbi "FC:"') do (
    set /a "Y=0x%%i"
    for /l %%k in (!X! 1 !Y!) do echo 41
    set /a "X=Y+2"
    echo %%j
  )
)
del !Cmp!

REM read certain values out of the HEX dump
set "err="
<!Dmp! (
  set /p "A="
  set /p "B="
  REM magic number has to be "MZ"
  if "!A!!B!" neq "4D5A" (set "err=2") else (
    REM skip next 58 bytes
    for /l %%i in (3 1 60) do set /p "="
    REM bytes 61-64 contain the offset to the PE header in little endian order
    set /p "C="
    set /p "D="
    set /p "E="
    set /p "F="
    REM check if the beginning of the PE header is part of the HEX dump
    if 0x!F!!E!!D!!C! lss 1 (set "err=3") else (
      if 0x!F!!E!!D!!C! gtr 1018 (set "err=3") else (
        REM skip the offset to the PE header
        for /l %%i in (65 1 0x!F!!E!!D!!C!) do set /p "="
        REM next 4 bytes have to contain the signature of the PE header
        set /p "G="
        set /p "H="
        set /p "I="
        set /p "J="
        REM next 2 bytes contain the CPU identifier in little endian order
        set /p "K="
        set /p "L="
      )
    )
  )
)
del !Dmp!
if defined err (endlocal &endlocal &cmd /c exit 0 &exit /b %err%)

REM was the signature ("PE\0\0") of the PE header found
if "%G%%H%%I%%J%"=="50450000" (
  REM calculate the decimal value of the CPU identifier
  set /a "CPUID=0x%L%%K%"
) else (endlocal &endlocal &cmd /c exit 0 &exit /b 4)
endlocal &endlocal &cmd /c exit %CPUID% &exit /b 0

Answer 21

Hier ist eine einfachere Methode für Batch-Skripten

    @echo off

    goto %PROCESSOR_ARCHITECTURE%

    :AMD64
    echo AMD64
    goto :EOF

    :x86 
    echo x86
    goto :EOF

Answer 22

Überprüfen Sie die Registrierung für die Existenz von HKLM \ SOFTWARE \ Wow6432Node - Wenn es sie gibt, ist das System 64-Bit -. 32-Bit, sonst