it-swarm.com.de

Ermitteln Sie, ob die aktuelle Windows-Version 32-Bit oder 64-Bit ist

Ob Sie es glauben oder nicht, mein Installationsprogramm ist so alt, dass es keine Option zum Erkennen der 64-Bit-Version von Windows bietet.

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

Eine mögliche Lösung

Ich sehe, dass Wikipedia angibt, dass die 64-Bit-Version von Windows XP und Windows Vista eine eindeutige Umgebungsvariable hat: %ProgramW6432%, Also schätze ich, dass dies unter 32-Bit-Windows leer wäre.

Diese Variable zeigt auf das Verzeichnis Program Files, In dem alle installierten Programme von Windows und anderen gespeichert sind. Die Standardeinstellung auf englischsprachigen Systemen ist C:\Program Files. In 64-Bit-Editionen von Windows (XP, 2003, Vista) gibt es auch %ProgramFiles(x86)%, das standardmäßig C:\Program Files (x86) ist, und %ProgramW6432%, Das standardmäßig C:\Program Files. Das %ProgramFiles% Selbst hängt davon ab, ob der Prozess, der die Umgebungsvariable anfordert, selbst 32-Bit oder 64-Bit ist (dies wird durch die Windows-auf-Windows-64-Bit-Umleitung verursacht).

62
Clay Nichols

Siehe das in So prüfen Sie, ob auf dem Computer ein 32-Bit- oder 64-Bit-Betriebssystem ausgeführt wird. Es enthält auch Anweisungen, um dies in der Registrierung zu überprüfen:

Sie können den folgenden Registrierungsspeicherort verwenden, um zu überprüfen, ob auf dem Computer ein 32- oder 64-Bit-Windows-Betriebssystem ausgeführt wird:

HKLM\HARDWARE\DESCRIPTION\System\CentralProcessor\0

Im rechten Bereich werden die folgenden Registrierungseinträge angezeigt:

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

Die obigen Angaben "x86" und "0x00000020 (32)" geben an, dass die Betriebssystemversion 32-Bit ist.

9
Leif Gruenwoldt

Um in einem Befehlsfeld nach einer 64-Bit-Version von Windows zu suchen, 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, die von cmd.exe (32-Bit- und 64-Bit-Version) nur auf Windows-64-Bit-Computern automatisch definiert wird.

63
Dror Harari

Hier ist ein Delphi-Code, mit dem Sie überprüfen können, 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;
20
Blorgbeard

Ich habe die in meiner Frage vorgeschlagene Lösung getestet:

Getestet für Windows-Umgebungsvariable: ProgramW6432

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

13
Clay Nichols

Aus einem Batch-Skript:

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

Unter Windows API :

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

Quellen:

  1. HOWTO: Prozesszeuge erkennen
  2. GetSystemWow64Directory-Funktion
13
Leif Gruenwoldt

Wenn Sie API-Aufrufe durchführen können, verwenden Sie GetProcAddress / GetModuleHandle , um zu überprüfen, ob IsWow64Process vorhanden ist, das nur in Windows-Betriebssystemen mit 64 vorhanden ist -Bit-Versionen.

Sie können auch die Umgebungsvariable ProgramFiles (x86) ausprobieren, die in Vista/2008 aus Gründen der Abwärtskompatibilität verwendet wird, bei XP-64 bin ich mir jedoch nicht 100% sicher oder 2003-64.

Viel Glück!

8
Jason

Ich habe dies in einem Anmeldeskript verwendet, um 64-Bit-Windows zu erkennen

if "% ProgramW6432%" == "% ProgramFiles%" goto is64flag

6
TallGuy

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

Wenn Sie nur wissen möchten, ob Ihre Anwendung 32-Bit oder 64-Bit ausführt, können Sie IntPtr.Size. Bei Ausführung im 32-Bit-Modus ist es 4 und bei Ausführung im 64-Bit-Modus 8.

4
Andrew Ensley

Informationen zu einem VBScript/WMI-Einzeiler, der die tatsächliche Bitnummer (32 oder 64) des Betriebssystems oder der Hardware abruft, finden Sie unter http://csi-windows.com/toolkit/csi-getosbits

4
Darwin

Ich möchte hier hinzufügen, was ich in Shell-Skripten verwende (kann aber problemlos in jeder Sprache verwendet werden). Der Grund ist, dass einige der Lösungen hier nicht mit einem WoW64 funktionieren, andere Dinge verwenden, die nicht wirklich dafür gedacht sind (prüfen, ob es einen * (x86) -Ordner gibt) oder in Cmd-Skripten nicht funktionieren. Ich bin der Meinung, dies ist die "richtige" Vorgehensweise und sollte auch in zukünftigen Windows-Versionen sicher sein.

 @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
3
Josef

In vielen Antworten wird der Aufruf von IsWoW64Process() oder verwandter Funktionen erwähnt. Dies ist nicht der richtige Weg. Sie sollten GetNativeSystemInfo() verwenden, das für diesen Zweck entwickelt wurde. Hier ist 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/en-us/library/windows/desktop/ms724340%28v=vs.85%29.aspx

3
jcoffland

Ich weiß nicht, auf welcher Windows-Version es existiert, aber unter Windows Vista und höher läuft dies:

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

In C #:

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

In VB.NET :

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

Ich benutze das:

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

Es funktioniert unter Windows XP, getestet unter Windows XP Professional Sowohl 64-Bit als auch 32-Bit.

1
user83250

Der beste Weg ist sicher nur zu überprüfen, ob es zwei Programmdateiverzeichnisse gibt, 'Program Files' und 'Program Files (x86)'. Der Vorteil dieser Methode ist, dass Sie dies tun können, wenn das Betriebssystem nicht ausgeführt wird, zum Beispiel wenn Der Computer konnte nicht gestartet werden und Sie möchten das Betriebssystem neu installieren

0
jasee

Ich habe die folgende Batchdatei unter Windows 7 x64/x86 und Windows XP x86 und es ist in Ordnung, aber ich habe Windows XP x64 noch nicht ausprobiert, aber dies 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) 
0
Match

Hier ist eine einfachere Methode für Batch-Skripte

    @echo off

    goto %PROCESSOR_ARCHITECTURE%

    :AMD64
    echo AMD64
    goto :EOF

    :x86 
    echo x86
    goto :EOF
0
Max

Ich weiß, das ist uralt, aber hier ist, was ich benutze, um Win764 zu 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
0
Verbose

Wenn in Windows Powershell der folgende Ausdruck true zurückgibt, handelt es sich um ein 64-Bit-Betriebssystem:

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

Dies wurde entnommen und geändert aus: http://depsharee.blogspot.com/2011/06/how-do-detect-operating-system.html (Methode # 3). Ich habe dies auf Win7 64-Bit (in 32- und 64-Bit-PowerShell-Sitzungen) und XP 32-Bit) getestet.

0
CJBS

Interessanterweise, wenn ich benutze

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

Ich bekomme AMD64 sowohl in 32-Bit- als auch in 64-Bit-ISE (unter Win7 64-Bit).

0
Mike Shepard

Ein anderer Weg erstellt von eGerman , der die PE-Nummern kompilierter ausführbarer Dateien verwendet (nicht von Registrierungsdatensätzen oder Umgebungsvariablen abhängig):

@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
0
npocmaka