OS Version Windows 10 ermitteln.

[holliesoft]

Zitat:

Gerade versucht und gescheitert. Unter Windows 10 (1703) bekomme ich 10.0.15063.0 bei ProductVersion.

15063 ist die korrekte Buildnummer der 1703. Schau mal in Winver.exe, da stehts.

[TERWI]

... ich hol den Thread noch mal hoch ...
Betreff der Diskussionen zur Notwendigkeit (& Richtigkeit) einer Versionsprüfung gebe ich aus meiner Sicht z.B. die "WLAN-API" mal zu Bedenken.
Dort gibt es seit XP über Vista, Win 7 und Win 8 je Version neue Funktionen, wo es schon Wissenswert ist, welches OS läuft und welche Funktionalität das Proggie damit noch gewährleisten kann
Ab WIN 10 gibt es dann eh eine neue API - ob die "alte" dort noch funzt ? (Hab z.Zt. keinen WIN-10 Rechner greifbar).

Problem scheint ja offensichtlich zu sein, das nicht nur Delphi-interne Funktionen u. a. API-Funcs scheinbar bei der Version 6.2 stehengeblieben sind - sofern hier kein Manifest-Update stattfindet. Angeblich soll WIN 10 dann auch 6.4 melden...

Die Registry auszulesen halte ich hier nach wie vor am sinnigsten - wird es diese doch sicher auch mit/nach WIN 11 o. ä. aus Kompatibilitätsgründen weiterhin geben / geben müssen !?
Mit WIN 8.1 bekomme ich hier als 'CurrentVersion' 6.3 - ohne ohne Änderung am Manifest.

Im Post #18 beschreibt Gerd01 seine Reg zur "CurrentVersion" für WIN 10.
Dort sieht man die Einträge "CurrentMajorVersionNumber" mit Wert=10 und "CurrentMinorVersionNumber" mit Wert = 0, die es in Versionen darunter nicht gibt.
Warum diese nicht zusätzlich prüfen ? Da offensichtlich neu in WIN 10 wird es diese mit entsprehenden Versions-Nummer sicher auch weiterhin geben.
Build-Nr und Produkt-Name u. a. sind auch so wie bisher

Ich hab mir dazu mal ein kleines, noch übersichtliches Tool gebastelt, was auf eine erforderlich Minimal-Version/Build testet und ggf. eine Info auswirft:

Delphi-Quellcode:

function CheckWinVer(var WinVerMaj : integer;
                     var WinVerMin : integer;
                     var WinVerBuild : integer;
                     var WinProdName : string;
                     ShowMsg : boolean) : boolean;
var
  reg: TRegistry;  // USES: Registry
  s1, s2 : string;
  MemVerMaj   : integer;
  MemVerMin   : integer;
  MemVerBuild : integer;
  MsgType     : TMsgDlgType;
begin
  result      := true;
  MsgType     := TMsgDlgType.mtInformation;
  MemVerMaj   := WinVerMaj;
  MemVerMin   := WinVerMin;
  MemVerBuild := WinVerBuild;
  reg := TRegistry.Create(KEY_READ);
  reg.RootKey := HKEY_LOCAL_MACHINE;
  if reg.OpenKey('SOFTWARE\Microsoft\Windows NT\CurrentVersion',false) then
  begin
    // since WIN 10:
    try
      WinVerMaj := reg.ReadInteger('CurrentMajorVersionNumber'); // dword:0000000a
      WinVerMin := reg.ReadInteger('CurrentMinorVersionNumber'); // dword:00000000
    except
      WinVerMaj := -1;
      WinVerMin := 0;
    end;
    if (WinVerMaj < 0) then
    begin
      s1 := reg.ReadString('CurrentVersion');
      s2 := Copy(s1, 1, Pos('.', s1) - 1);
      WinVerMaj := strtoint(s2);
      s2 := Copy(s1, Pos('.', s1) + 1, length(s1));
      WinVerMin := strtoint(s2);
    end;
    s1 := reg.ReadString('CurrentBuildNumber');
    WinVerBuild := strtoint(s1);
    WinProdName := reg.ReadString('ProductName');
    s1 := 'OS-Version: ' + WinProdName + #10#13 +
          inttostr(WinVerMaj) + '.' + inttostr(WinVerMin) + ' - Build ' + inttostr(WinVerBuild);
    s2 := '';
    // check necessaryVersion
    if NOT (WinVerMaj >= MemVerMaj) then
    begin
      s2 := #10#13 + '-> Major-Version lower as expected ! (' + inttostr(MemVerMaj) + ')';
      result := false;
    end;
    // if NOT (WinVerMin >= MemVerMin) then --- nicht ganz richtig ...
    if (NOT (WinVerMaj > MemVerMaj)) AND (NOT (WinVerMin >= MemVerMin)) then
    begin
      s2 := s2 + #10#13 + '-> Minor-Version lower as expected ! (' + inttostr(MemVerMin) + ')';
      result := false;
    end;
    if NOT (WinVerBuild >= MemVerBuild) then
    begin
      s2 := s2 + #10#13 + '-> Build-Nr. lower as expected ! (' + inttostr(MemVerBuild) + ')';
      result := false;
    end;
    if NOT result then
      MsgType := TMsgDlgType.mtWarning;
  end
  else
  begin
    result      := false;
    MsgType     := TMsgDlgType.mtError;
    WinVerMaj   := -1;
    WinVerMin   := -1;
    WinVerBuild := -1;
    WinProdName := 'Unknown Version';
    s1 := 'WARNING: Determine OS-Version failed !';
    s2 := '';
  end;
  reg.CloseKey();
  reg.Free;
  if ShowMsg then
  begin
    MessageDlg(s1 + s2, MsgType, [mbOK], 0);
  end;
end;

Aufruf:

Delphi-Quellcode:

// globale var's:
    FWinVerMaj   : integer;
    FWinVerMin   : integer;
    FWinBuild    : integer;
    FWinProdName : string;
....
// Definition min. z. B.:
  FWinVerMaj   := 6;   // >= XP     > 6 für WIN 10
  FWinVerMin   := 1;   // >= WIN 7  > 3 für WIN 10
  FWinBuild    := -1;  // no check
  FWinProdName := '';  // default
// Aufruf:
  if NOT CheckWinVer(FWinVerMaj,
                     FWinVerMin,
                     FWinBuild,
                     FWinProdName,
                     true) then // ShowMsg
    close; // ... oder halt was anderes ...

Funzt hier beim Test auf XP, WIN 7 und WIN 8.1 - je nach Vorgabe der Min.-Version
Könnte das mal bitte jemand mit einem WIN-10-Rechner testen ?

[bra]

OS-Version: Windows 10 Enterprise
10.0 - Build 15063
-> Minor-Version lower as expected ! (1)

So ist die Prüfung aber nicht sinnvoll, oder? Weil 10.0 ja größer als 6.1 sein sollte?

[TERWI]

Scheint ja wie gewünscht mit den beiden "neuen" Reg-Einträgen zu funktionieren:
Es wird korrekt 10.0 geliefert.
Die Antwort zum "Gemecker" steht dort schon:
-> Minor-Version lower as expected ! (1)
... mal die Definition zur Minor-Version ändern:
  FWinVerMin := 0;


Ooops - EDIT, ein Käfer.... (ist im Code auf S. 7 #59 bereits geändert)
Falsch ist die Zeile:
if NOT (WinVerMin >= MemVerMin) then Die Minor-Ver. sollte nicht geprüft werden, wenn die Major-Ver. größer als gefordert ist.
Bitte ersetzen mit:
if (NOT (WinVerMaj > MemVerMaj)) AND (NOT (WinVerMin >= MemVerMin)) then

[BerndS]

Hallo,
Ich habe auf meinem PC Windows 10 Pro (64bit) 1903 und wunderte mich das mir meine Funktion als ProductName Windows 10 Enterprise anzeigt.
In habe mit Regedit die Werte anzeigen lassen und da stehen die richtigen Werte drin.
Das Problem tritt bei mir in einer 32 bit Anwendung auf.
Wie sich das unter 64 bit verhält kann ich nicht testen, da ich diese Zielplattform nicht installiert habe.

Durch die Suche habe ich diesen Thread gefunden. Dort wird im Beitrag 67 der ProductName auch falsch aus der Registry zurück gegeben.
Ich habe das Problem durch das Hinzufügen von KEY_WOW64_64KEY lösen können.

TRegistry.Create(KEY_READ or KEY_WOW64_64KEY) Vielleicht ist dies Info für jemand hilfreich der diese Funktion nutzt.
Gruß Bernd

[TiGü]

Zitat von TERWI:

... ich hol den Thread noch mal hoch ...
Betreff der Diskussionen zur Notwendigkeit (& Richtigkeit) einer Versionsprüfung gebe ich aus meiner Sicht z.B. die "WLAN-API" mal zu Bedenken.

Konkret an dem Beispiel:
Statt immer zu prüfen, welche Windowsversion vorliegt, kann ja auch stattdessen auf die Funktionalität prüfen.
Also ob die DLL vorhanden ist, die die gesuchten Funktion enthält und dann per dynamischen Laden nachsehen, ob ich einen Zeiger auf die Funktion bekomme.
Oder - so kenne ich das von DirectX - man prüft über QueryInterface (oder Supports), ob die Instanz eines Betriebssystemsinterfaces, welches ich von einer Basisfunktion bekommen habe, weitere, neue Interfaces implementiert.

Beispiel: In Windows 98 wurde das Interface IFoo eingeführt. Dieses kommt aus der \Windows\System32\Foo.dll von der GetFooInstance()-Funktion.
Unter Windows Vista gab es neue Funktionalität. IFoo wurde abgeleitet und heißt jetzt IFoo2 = interface(IFoo).
Mit Windows 7 kam IFoo3, mit Windows 8 IFoo4 usw.

So kann ich dann beim Programmieren prüfen:

Delphi-Quellcode:

var
  HR: HRESULT;
  Foo: IFoo;
  Foo2: IFoo2;
  Foo3: IFoo3;
  Foo4: IFoo4;
  Foo5: IFoo5;
begin
  HR := GetFooInstance(Foo);
  if Succeded(HR) then
  begin
    if Supports(Foo, IFoo2, Foo2) then
      Bar2(Foo2);

    if Supports(Foo, IFoo3, Foo3) then
      Bar3(Foo3);

    if Supports(Foo, IFoo4, Foo4) then
      Bar4(Foo4);

    if Supports(Foo, IFoo5, Foo5) then
      Bar5(Foo5);
  end;

[TERWI]

Damit wir uns hier (alle) nicht missverstehen: Auch ich bin der Meinung, dass man NICHT IMMER eine Versionsprüfung machen muss ....
.... ich persönlich erachte es jedenfalls als recht sinnvoll, bereits beim Prog-Start diese zu prüfen und ggf. den Anwender darauf hinzuweisen, dass die Funktionalität evtl. eingeschränkt ist oder unter eben der OS-Ver. nix geht.
Das ist eben besonders bei der WLan-API recht augenfällig. Bei den versch. DirectX-Ver. ist es genau das gleiche.

Logo kann (und sollte !) man auf DDL-, Funktion/Zeiger darauf vorhanden u.v.m. Nur kann man sich ne Menge Tipperei & Prüferei sparen, wenn man Elementares schon vorher weiss. Wenn es denn wichtig erscheint ...

Die kleine Func war auch nur so ne Idee, ob das denn auch allein mit der Registry klappt. Scheint wohl so.
Geht natürlich auch anders, wie hier schon mehrfach angedeutet.

[hoika]

Hallo,
ich hole mit die Build-Nummer von Windows 10 so:

Delphi-Quellcode:

function ErmittleWindows10Build: String;
var
  Reg: TRegistry;
begin
  Result := '';
  try
    Reg:= TRegistry.Create(KEY_READ);
    try
      Reg.RootKey := HKEY_LOCAL_MACHINE;
      if Reg.OpenKeyReadOnly('SOFTWARE\Microsoft\Windows NT\CurrentVersion') then
      begin
        Result := Reg.ReadString('ReleaseId');
        Reg.CloseKey;
      end;
    finally
      Reg.Free;
    end;
  except
  end;
end { ErmittleWindows10Build } ;

und zwar nur dann, wenn die Major=8/Minor=2 (>=Windows 8) und die Major der kernel32.dll=10 ist.