OS Version ermitteln

[Luckie]

Ich weiß, dass es davon genug Versionen gibt, also warum nicht noch eine?

Könntet ihr es bitte mal testen? Ich habe es unter Windows 7 unter den verschiedenen Kompatibilitätsmodi ausprobiert. Klappt alles, bis auf Server 2008, da bekomme ich immer Vista raus.

Projekt im Anhang.

[toms]

Hallo Michael

1. Sehe ich es richtig: Wenn Architecture = AMD64 dann 64-bit, wenn Architecture = Intel dann 32-bit ?

Delphi-Quellcode:

GetSystemInfo(si);
  if (osvi.dwMajorVersion >= 6) then
  begin
    if (si.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_AMD64) then
      Result := Result + ' 64-bit'
    else if (si.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_INTEL) then
      Result := Result + ' 32-bit';
  end;
end

2. LoadLibrary ... FreeLibrary (zudem lädst du zwei Mal den Kernel)

3. (Noch) nicht Unicode tauglich.

Aufruf von GetVersionEx gibt Fehler 'The data area passed to a system call is too small'.

[RWarnecke]

Hallo Michael,

auf einer Windows XP Professional SP3 Installation kommt als Ergebnis:

---------------------------
Project1
---------------------------
Windows XP Home Edition Service Pack 3 Build: 2600
---------------------------
OK
---------------------------

Ich habe mir zwar mal den Quelltext angeschaut, nur finde ich da ohne Delphi gerade den Fehler nicht. Für die Windows-API GetProductInfo gibt es noch mehr Ergbenisse. Die API arbeitet sehr zuverlässig, da ich diese bei mir im SystemInfo einsetze.

Edit:
Um zu überprüfen, ob das OS 32Bit oder 64Bit ist, würde ich diese Funktion nehmen :

Delphi-Quellcode:

////////////////////////////////////////////////////////////////////////////////
//
//  Bestimmen ob das Betriebssystem 64Bit ist oder nicht
//
function IsWow64: Boolean;
type
  TIsWow64Process = function(Handle: Windows.THandle; var Res: Windows.BOOL): Windows.BOOL; stdcall;
var
  IsWow64Result: Windows.BOOL;      // Result from IsWow64Process
  IsWow64Process: TIsWow64Process;  // IsWow64Process fn reference
begin
  // Try to load required function from kernel32
  IsWow64Process := Windows.GetProcAddress(Windows.GetModuleHandle('kernel32'), 'IsWow64Process');
  if Assigned(IsWow64Process) then
  begin
    // Function is implemented: call it
    if not IsWow64Process(Windows.GetCurrentProcess, IsWow64Result) then
      raise SysUtils.Exception.Create('IsWow64: bad process handle');
    // Return result of function
    Result := IsWow64Result;
  end
  else
    // Function not implemented: can't be running on Wow64
    Result := False;
end;

Dazu gibt es auch einen Beitrag hier im Forum, finde aber zu Zeit den Link nicht mehr.

[Jens Hartmann]

Hallo Michael,

leider Funktioniert es bei Windows 7 Professional 64-Bit auch nicht. Da kommt die Meldung 32-Bit.

Gruß Jens

[Nersgatt]

Windows 7 Prof 32 Bit: Passt
Windows XP home SP3: Passt nicht
---------------------------
Project1
---------------------------
Windows XP Professional Service Pack 3 Build: 2600
---------------------------
OK
---------------------------
(schön wärs )

[Neutral General]

Hallo.

Prinzipiell stimmts bei mir:

---------------------------
Project1
---------------------------
Windows Vista rocessExefileBusiness Edition Service Pack 1 Build: 6001 32-bit
---------------------------
OK
---------------------------

Aber da hat sich glaube ich irgendwas dazwischen geschummelt, was da nicht hingehört

[Delphi-Laie]

Zitat von RWarnecke:

Um zu überprüfen, ob das OS 32Bit oder 64Bit ist, würde ich diese Funktion nehmen :

Delphi-Quellcode:

////////////////////////////////////////////////////////////////////////////////
//
//  Bestimmen ob das Betriebssystem 64Bit ist oder nicht
//
function IsWow64: Boolean;
type
  TIsWow64Process = function(Handle: Windows.THandle; var Res: Windows.BOOL): Windows.BOOL; stdcall;
var
  IsWow64Result: Windows.BOOL;      // Result from IsWow64Process
  IsWow64Process: TIsWow64Process;  // IsWow64Process fn reference
begin
  // Try to load required function from kernel32
  IsWow64Process := Windows.GetProcAddress(Windows.GetModuleHandle('kernel32'), 'IsWow64Process');
  if Assigned(IsWow64Process) then
  begin
    // Function is implemented: call it
    if not IsWow64Process(Windows.GetCurrentProcess, IsWow64Result) then
      raise SysUtils.Exception.Create('IsWow64: bad process handle');
    // Return result of function
    Result := IsWow64Result;
  end
  else
    // Function not implemented: can't be running on Wow64
    Result := False;
end;

Das scheint nur mit 32-Bit-Programmen zu funktionieren, was auch logisch ist, weil 64-Bit-Programme nicht unter "wow64" laufen. Also ist diese Funktion als universeller Quelltext für 32- und 64-Bit-Compilate (Lazarus!) untauglich. Mit den Compilerschaltern {$IFDEF CPU32},{$IFDEF CPU64}, {$IFDEF WIN32} und/oder {$IFDEF WIN64} ist aber eine zufriedenstellende Anpassung und Ergänzung dieser Funktion möglich, so daß bei 64-Bit-Compilaten (die auf Win32-System ohnehin nicht laufen) automatisch der Wert true zurückgegeben wird.

Zu ergänzen wäre noch, daß

- unter Windows 32 Bit 64-Bit-Prozessoren von Lazarus nicht als solche (also mit 64 Bit) erkannt werden (das ist naheliegend)
- Lazarus 32 Bit unter Windows 64 Bit auch nur 32 Bit sowohl beim Prozessor als auch beim Betriebsprogramm erkennt (was m.E. ebenso naheliegend ist),

so daß mir nicht klar ist, wann {$IFDEF CPU32}<>{$IFDEF CPU64} und/oder {$IFDEF WIN32}<>{$IFDEF WIN64} jemals eintreffen sollte (CPU64 kann nur unter WIN64 festgestellt werden, umgekehrt gilt das erst recht).

Also, die obige Prozedur z.B. mit einem der beiden 32-Bit-Compilerschalter "eingekreist" (oder eingeleitet) und einem Else-Schalter (alternativ: Einer der beiden 64-Bit-Compilerschalter), der die Funkttion bei 64 Bit mit einem einfachen true zurückliefert, müßte das diese Funktion auch Bitanzahl-Plattform-übergreifend komplettieren.