Windows Version ermitteln

[Willie1]

Hallo liebe Delphi Community,

wg. meiner Augen bin ich kaum noch aktiv als Delphi Programmierer. Aber einen neues Notebook habe ich mir nach 10 Jahren gekauft, weil Vorlesen und Lupe sehr hilfreich für mich sind.

Meine alten Programme laufen auch unter Windows 11 gut. Eines fällt mir auf: ich zeige in der About-Box die Windows Version an und es lässt sich Win 11 nicht von Win 10 unterscheiden. Ich hatte ein kleines Testprogramm gebastelt. Siehe Screenshot. Ich habe gegooglelt und 2 Beiträge (StackOverflow, Ct) gefunden. Beide sagen, an der Build-Nummer lässt es sich unterscheiden. Build >= 22000 Windows 11. Stimmt das verbindlich? Ich habe nur 2 Systeme und kann es nur begrenzt ausprobieren. Wie erkennt W11 denn sich selbst? Winver zeigt es korrekt an.

Microsoft hat wohl kein großes Interesse an Windows 11, sonst würden sie W11 eine neue Versionsnummer gönnen.

Gruß Willie.

Der Screenshot zeigt W10 aber bei W11 ist nur die Build-Nummer anders.

[mmw]

Hallo,
mit WMI funktioniert es.

Delphi-Quellcode:

procedure GetCIM_OperatingSystemInfo;
const
  WbemUser = '';
  WbemPassword = '';
  WbemComputer = 'localhost';
  wbemFlagForwardOnly = $00000020;
var
  FSWbemLocator,
  FWMIService,
  FWbemObjectSet,
  FWbemObject: OLEVariant;
  oEnum: IEnumvariant;
  iValue: LongWord;

begin;
  FSWbemLocator := CreateOleObject('WbemScripting.SWbemLocator');
  FWMIService := FSWbemLocator.ConnectServer(WbemComputer, 'root\CIMV2', WbemUser, WbemPassword);
  FWbemObjectSet := FWMIService.ExecQuery('SELECT * FROM CIM_OperatingSystem', 'WQL', wbemFlagForwardOnly);

   oEnum := IUnknown(FWbemObjectSet._NewEnum) as IEnumVariant;
    while oEnum.Next(1, FWbemObject, iValue) = 0 do
     begin
      memo1.Lines.add(FWbemObject.Caption); //<<------ müsste entsprechend angepasst werden.
      FWbemObject:=Unassigned;
     end;
end;

aufruf

Delphi-Quellcode:

begin
 try
  memo1.Lines.clear;
  coInitialize(nil);
   try
    GetCIM_OperatingSystemInfo;
   finally
    CoUninitialize;
   end;

  except
   on E:EOleException do
       showmessage(Format('EOleException %s %x', [E.Message,E.ErrorCode]));
    on E:Exception do
        ShowMessage(E.Classname+' : '+ E.Message);
  end;
end;

ich habe es hiermit erstellt.

https://github.com/RRUZ/wmi-delphi-code-creator

Gruß

[kopernikus]

Man erkennt Windows 11 auch an der Build-Nummer. Sie ist größer oder gleich 22000.

[Willie1]

Zitat:

Zitat von mmw (Beitrag 1537074)

Hallo,
mit WMI funktioniert es.

Ja, das stimmt! Vielen Dank. Nur wenn ich mir den Quelltext ansehe, frage ich mich, muss es so kompliziert sein? Willie.

[himitsu]

TOSVersion

Aber wie es oft genug gesagt wird: Es wird nicht auf Versionen geprüft, sondern auf das Feature, welches benötigt wird.
Genauso, wie man nicht auf "Admin" prüft, sondern auf das Recht, welches nötig ist.

[Sharky]

Zitat:

Zitat von himitsu (Beitrag 1537117)

Es wird nicht auf Versionen geprüft, sondern auf das Feature

Das ist natürlich Unsinn.

Jeder, der sich mit den MS Produkten auskennt, weiß, dass er auf beides prüfen muss.
Feature in Windows X muss nicht die gleichen Funktionen wie das gleiche Feature in Windows Y haben.

[jaenicke]

Zitat:

Zitat von Sharky (Beitrag 1537118)

Zitat:

Zitat von himitsu (Beitrag 1537117)

Es wird nicht auf Versionen geprüft, sondern auf das Feature

Das ist natürlich Unsinn.

Jeder, der sich mit den MS Produkten auskennt, weiß, dass er auf beides prüfen muss.
Feature in Windows X muss nicht die gleichen Funktionen wie das gleiche Feature in Windows Y haben.

Den Fall hatte ich bisher tatsächlich extrem selten. Bisher konnte ich fast immer auf das Feature testen, und in den anderen Fällen wäre das mit etwas mehr Aufwand vermutlich auch gegangen, da ging es z.B. um das Touchhandling.

In welchen Fällen brauchtest du denn die Unterscheidung?

Zitat:

Zitat von Willie1 (Beitrag 1537072)

Microsoft hat wohl kein großes Interesse an Windows 11, sonst würden sie W11 eine neue Versionsnummer gönnen.

Tatsächlich hat Microsoft die echte Windowsversion aktiv vor Programmen verborgen, weil viele Entwickler auf die geniale Idee gekommen waren, auf bestimmte Versionen zu prüfen. Deshalb funktionierten plötzlich Programme mit einer neuen Version von Windows nicht mehr, obwohl es technisch gar kein Problem gegeben hätte. Das ist auch einer der Gründe, weshalb es keine größeren Sprünge mehr gab.

[himitsu]

Das Auslesen über die API hängt auch noch von der Virtualisierung ab.
Wird das Programm für Windows XP virtualisiert, dann sagt die API auch, es sei ein XP.

Da man dann auch die Features von XP bekommt, wäre bei einer Prüfung auf die Version dann XP auch vollkommen richtig,
und sich irgendwie auf wirren Wegen die "echte" Version zu besorgen bringt dann ja nicht viel, wenn dann das gewünschte Feature dort nicht erreichbar ist.

[Willie1]

Hi,
mein alter Kindergartenfreund schwört auf Windows 7 und das soll die älteste Version sein, die meine Programme unterstützen. Ihr hattet mir schon vor Jahren abgeraten, Abfragen wie

Delphi-Quellcode:

if IsWin7 then

zu benutzen. Ich frage überhaupt nichts ab. Das macht schon das Installationsprogramm InnoSetup. Ich will nur eine korrekte Anzeige der Windows Version in der About-Box. Siegt sonst doof aus. Die Größe des Arbeitsspeichers, die ich auch anzeige ist zum Glück seid Delphi 6 bis heute (Windows 98-Win 11) richtig geblieben.

Willie.

[DaCoda]

Du bekommst eigentlich alle Infos aus System.SysUtils.TOSVersion:

Code:

uses
  Syste.SysUtils;

  sTest := 'Betriebssystem: ' + TOSVersion.Name;
  sTest := 'Build: ' + TOSVersion.Build.ToString;

  etc.

[Willie1]

Zitat:

Zitat von DaCoda (Beitrag 1537152)

Du bekommst eigentlich alle Infos aus System.SysUtils.TOSVersion:

Code:

uses
  Syste.SysUtils;

  sTest := 'Betriebssystem: ' + TOSVersion.Name;
  sTest := 'Build: ' + TOSVersion.Build.ToString;

  etc.

Hallo DaCoda, bei Windows 10 wird alles außer der Buildnummer (=0) einschl. 64 Bit Edition richtig angezeigt. Windows 11 wird nicht erkannt. Mein Delphi ist alt, vielleicht ist es bei Delphi 11 korrigiert worden?!. Weiß das einer?

[jaenicke]

Zitat:

Zitat von Willie1 (Beitrag 1537150)

Ich will nur eine korrekte Anzeige der Windows Version in der About-Box.

Den Sinn habe ich nie verstanden. Soll das zeigen, dass man es schafft, das auszulesen? Wenn ich Details zu Windows möchte, warum sollte ich da in irgendeine Aboutbox schauen?

Aber das kann natürlich jeder machen wie er möchte.

[DaCoda]

Ich habe das mal getestet unter Windows 11:

Code:

   Listbox1.Items.Add(TOSVersion.Name);
   Listbox1.Items.Add(TOSVersion.Build.ToString);
   Listbox1.Items.Add(TOSVersion.Major.ToString);
   Listbox1.Items.Add(TOSVersion.Minor.ToString);

Ergebnis siehe beigefügtes Bild.

[TomyN]

Zitat:

Ich frage überhaupt nichts ab. Das macht schon das Installationsprogramm InnoSetup

Drum hab ich auch zwei Versionen davon auf dem Rechner. Weil meine Software kann noch XP und Win7, Innosetup ab 6.X zumindest kein XP mehr...

[Willie1]

Hallo DaCoda, dann hast du wahrscheinlich Delphi 11. Bei mir wird für Build, Major, Minor u.a. Integer Werte immer 0 angezeigt. Auch 11 wird nicht angezeigt.

Delphi-Quellcode:

TOSVesrion.ToString

Bei mir steht Windows 10 (Version 10.0 Build 0 64-Bit Edition) auf beiden Rechnern.

[DaCoda]

Hallo Wille,
hol dir die Info's doch direct aus der Registry:

[jaenicke]

Zitat:

Zitat von DaCoda (Beitrag 1537164)

Hallo Wille,
hol dir die Info's doch direct aus der Registry:

Es ging ja darum, dass Windows 11 auch als Windows 11 erkannt wird. An der Stelle steht auch unter Windows 11 aber "Windows 10 Pro".

[himitsu]

Wie wir im Manifest sehen, ist ein Windows 11 ja auch ein 10 ... hat jedenfalls die selbe GUID :stupid:

[jaenicke]

Zitat:

Zitat von himitsu (Beitrag 1537174)

Wie wir im Manifest sehen, ist ein Windows 11 ja auch ein 10 ... hat jedenfalls die selbe GUID :stupid:

Windows 10 ist ja auch die letzte Windowsversion. :lol:

[himitsu]

macOS ist auch nur der neue Name ... intern ist es doch auch nur ein OS X, also soooo verkehrt kann es nicht sein :stupid:

[Willie1]

Zitat:

Zitat von DaCoda (Beitrag 1537164)

Hallo Wille,
hol dir die Info's doch direct aus der Registry:

Sieh dir meinen Screenshot an, Methode 3 benutzt die Registry, es steht Windows 10 da! Ich will nur die installierte Windows Version ermitteln.

Mit WMI klappt das offensichtlich auch bei Windows 11. Bei https://www.der-windows-papst.de/wp-...-einsetzen.pdf steht, dass man auch mit WMI die Build Nummer ermitteln kann. Ich habe WMI nicht gelernt, kann einer von euch das verstehen?

[mmw]

Hallo,

das geht auch.

Delphi-Quellcode:

procedure GetWin32_OperatingSystemInfo;
const
  WbemUser = '';
  WbemPassword = '';
  WbemComputer = 'localhost';
  wbemFlagForwardOnly = $00000020;
var
  FSWbemLocator,
  FWMIService,
  FWbemObjectSet,
  FWbemObject: OLEVariant;
  oEnum: IEnumvariant;
  iValue: LongWord;
begin;
  FSWbemLocator := CreateOleObject('WbemScripting.SWbemLocator');
  FWMIService := FSWbemLocator.ConnectServer(WbemComputer, 'root\CIMV2', WbemUser, WbemPassword);
  FWbemObjectSet := FWMIService.ExecQuery('SELECT * FROM Win32_OperatingSystem', 'WQL', wbemFlagForwardOnly);
  oEnum := IUnknown(FWbemObjectSet._NewEnum) as IEnumVariant;
  while oEnum.Next(1, FWbemObject, iValue) = 0 do
   begin
    memo1.Lines.add(Format('BootDevice                                   %s',[String(FWbemObject.BootDevice)]));
    Memo1.Lines.add(Format('BuildNumber                                  %s',[String(FWbemObject.BuildNumber)]));// String
    Memo1.Lines.Add(Format('Caption                                      %s',[String(FWbemObject.Caption)]));// String
    FWbemObject:=Unassigned;
   end;
end;


begin
 try
  memo1.Lines.Clear;
  CoInitialize(nil);
   try
    GetWin32_OperatingSystemInfo;
   finally
    CoUninitialize;
   end;
 except
    on E:EOleException do
        Writeln(Format('EOleException %s %x', [E.Message,E.ErrorCode]));
    on E:Exception do
        Writeln(E.Classname, ':', E.Message);
 end;
 end;

komplette Beschreibung hier -
https://learn.microsoft.com/de-de/wi...peratingsystem

habe ich mit dem glreichen Programm erstellt siehe #2. Der Code Schnipsel muss wieder angepasst werden.

Gruß

[KodeZwerg]

So mache ich es, es liest Major, Minor, Build und Revisionsnummber von Windows aus.
Kompatibel mit Turbo Delphi 2006, FreePascal, RADStudio etc...
Es erscheint nicht "Das ist Windows 11" sondern was auch immer Windows selbst für sich hinterlegt hat als numerischer Wert.

Delphi-Quellcode:

program winverex;

{$APPTYPE CONSOLE}

uses
  Windows, SysUtils;

type
  TWindowsVersion = packed record
    Major,
    Minor,
    Build,
    Revision: DWORD;
  end;

function GetWindowsVersion: TWindowsVersion;
type
  TVSFixedFileInfo = record
    dwSignature,
    dwStrucVersion,
    dwFileVersionMS,
    dwFileVersionLS,
    dwProductVersionMS,
    dwProductVersionLS,
    dwFileFlagsMask,
    dwFileFlags,
    dwFileOS,
    dwFileType,
    dwFileSubtype,
    dwFileDateMS,
    dwFileDateLS: DWORD;
  end;
  PVSFixedFileInfo = ^TVSFixedFileInfo;
  TRtlGetNtVersionNumbers = procedure(out MajorVersion, MinorVersion, BuildNumber: DWORD); stdcall;
var
  RtlGetNtVersionNumbers: TRtlGetNtVersionNumbers;
  hLib: HINST;
  dwHandle: DWORD;
  pBuffer: Pointer;
  pVersionInfo: PVSFIXEDFILEINFO;
  dwLen: DWORD;
  WindowsDir: array[0..Pred(MAX_PATH)] of AnsiChar;
  WideWindowsDir: WideString;
  GotRtlVer: Boolean;
begin
  dwHandle := 0;
  pVersionInfo := nil;
  GotRtlVer := False;
  GetWindowsDirectory(WindowsDir, MAX_PATH);
  StrCat(WindowsDir, '\System32\Ntdll.dll');
  SetString(WideWindowsDir, PAnsiChar(@WindowsDir[0]), Length(WindowsDir));
  hLib := LoadLibraryW(PWideChar(WideWindowsDir));
  if hLib <> 0 then
    begin
      RtlGetNtVersionNumbers := TRtlGetNtVersionNumbers(GetProcAddress(hLib, 'RtlGetNtVersionNumbers'));
      if Assigned(RtlGetNtVersionNumbers) then
        begin
          RtlGetNtVersionNumbers(Result.Major, Result.Minor, Result.Build);
          GotRtlVer := True;
        end;
      FreeLibrary(hLib);
    end;
  Result.Revision := 0;
  dwLen := GetFileVersionInfoSizeW(PWideChar(WideWindowsDir), dwHandle);
  if dwLen > 0 then
    begin
      pBuffer := AllocMem(dwLen);
      try
        if GetFileVersionInfoW(PWideChar(WideWindowsDir), dwHandle, dwLen, pBuffer) then
          begin
            if VerQueryValueW(pBuffer, '\', Pointer(pVersionInfo), dwLen) then
              begin
                if not GotRtlVer then
                  begin
                    Result.Major := HiWord(pVersionInfo^.dwFileVersionMS);
                    Result.Minor := LoWord(pVersionInfo^.dwFileVersionMS);
                  end;
                Result.Build := HiWord(pVersionInfo^.dwFileVersionLS);
                Result.Revision := LoWord(pVersionInfo^.dwFileVersionLS);
              end;
          end;
      finally
        FreeMem(pBuffer);
      end;
    end;
end;

var
  WindowsVersion: TWindowsVersion;
begin
  WindowsVersion := GetWindowsVersion;
  WriteLn(Format('Windows version: %d.%d.%d.%d', [WindowsVersion.Major, WindowsVersion.Minor, WindowsVersion.Build, WindowsVersion.Revision]));
  WriteLn('Done');
  ReadLn;
end.

[himitsu]

PS: Nicht im GetIt nach WMI suchen! :zwinker:

[mmw]

evtl. hier -
https://github.com/NeftaliDelphi/GLi...readme-ov-file

Gruß

[uligerhardt]

Zitat:

Zitat von himitsu (Beitrag 1537215)

PS: Nicht im GetIt nach WMI suchen! :zwinker:

Ok, IDE startet... :-D

[Willie1]

Die Methode von mmw funktioniert bei Windows 10 und 11 und wird auch bei 12(?) laufen. Ich übernehme sie . Major, Minor usw. werden von Windows 11 ignoriert.

CodeZwerg: ich bin mit Delphi Berlin nicht gerade aktuell aber Delphi 2006 und Turbo Delphi sind mit meinem alten Notebook voriges Jahr gestorben.

Schönen Feiertag in den entsprechenden Bundesländern Willie.

[mmw]

Hallo,

Nachtrag -

mit den bei den Jedi- Komponenten vorhandenen unit 'jclSysInfo' funktioniert es auch (sollte, mit Delphi 10.4.2 Starter getestet)

'jclSysInfo.GetWindowsVersionString'
'jclSysInfo.GetWindowsBuildNumber'

Gruß

[Willie1]

Zitat:

Zitat von mmw (Beitrag 1537321)

mit den bei den Jedi- Komponenten vorhandenen unit 'jclSysInfo' funktioniert es auch (sollte, mit Delphi 10.4.2 Starter getestet)

'jclSysInfo.GetWindowsVersionString'
'jclSysInfo.GetWindowsBuildNumber'

Das ist gut zu wissen. Ich sehe, bei Delphi 11 liefert SysUtils.TOSVersion.ToString das richtige Ergebnis bei Win 10 und 11.
Wille