Info-Fenster von Windows anzeigen

[Willie1]

Hallo Leute,
ich möchte das Info-Fenster von Windows, dass die aktuelle Windows Version, auch für 10 anzeigt, aus einem eigenen Programm aufrufen.Wie mache ich das?
Lässt sich auch mit Powershell winver anzeigen.
Danke und Gruß
Willie.

[ringli]

Versuch doch mal die winver.exe im Windows-Systemverzeichnis. ;)

[Helmi]

meinst du so?

Delphi-Quellcode:

type
  TVersionInfo = packed record
    Major  : DWORD;
    Minor  : DWORD;
    Release: DWORD;
    Build  : DWORD;
  end;

{...}

var
  S          : String;
  VersionInfo: TVersionInfo;

begin
  VersionInfo := GetFileVersion(PWideChar(Application.ExeName));

  S := Format('Copyright by me!' + #13 + 'Version: %d.%d.%d.%d',
              [VersionInfo.Major, VersionInfo.Minor, VersionInfo.Release, VersionInfo.Build]);

  ShellAbout(self.Handle, PWideChar(Text), PWideChar(S), Application.Icon.Handle);
end;

[hathor]

Parameter von WINVER.exe gibt es bis WIN8.1 nicht.

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var  strParams,FN : String;
begin                                          // uses Winapi.ShellAPI
 strParams:= ''; // für Programme MIT Parameter
 FN:='winver.exe';
ShellExecute(Application.Handle,NIL,PWChar(FN), PWChar(strParams),NIL, SW_Normal);
end;

[Willie1]

Hallo Helmi,
dein Code ist genau das, was ich mir vorgestellt habe!!! Auch als Hobby-Programmierer will man eine schöne About-Box haben. Nur mit GetFileVersion habe ich ein Problem, es liefert einen Cardinal-Wert zurüch: Hiword enthält Hauptversion, Loword Nebenversion, kein Release und Built. Aber ich habe ein Codeschnipzel von Luckie gefunden. Die Windows-Infobox ist ja nützlich, weil sich die Windowsversion seit 8.1 nicht mehr so leicht ermitteln lässt. Von ShellAbout habe ich noch nie etwas gehört, obwohl ich viel in Delphiforen gesucht habe.
Hallo Hathor, dass klappt auch, danke.
Gruß Willie.

[Willie1]

Nachtrag:
Meine Begeisterung für eine About-Box (ShellAbout) mit Windows lässt schnell nach. Unter Windows 10 wird Text in der Kopfzeile stur ignoriert (immer nur Info) und es wird dann die falsche Windows-Version angezeigt Version 6.2 (Built 9200) also Windows 8. Ohne ShellAbout stimmt die Windows Version 10.0. Built 10240.
Willie

[Helmi]

Hallo,

sorry, hab übersehen, dass "GetFileVersion" eine eigene Procedure ist.

Hier mal der gesamte (Test-)Code:

Delphi-Quellcode:

unit Unit2;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, ShellAPI;

type
   TVersionInfo = packed record
     Major : DWORD;
     Minor : DWORD;
     Release: DWORD;
     Build : DWORD;
   end;

type
  TForm2 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form2: TForm2;

implementation

{$R *.dfm}

function GetFileVersion(const FileName: PWideChar): TVersionInfo;
var
  VerInfoSize : Integer;
  VerValueSize: DWord;
  Dummy       : DWord;
  VerInfo     : Pointer;
  VerValue    : PVSFixedFileInfo;

begin
  VerInfoSize := GetFileVersionInfoSize(Filename,Dummy);

  If VerInfoSize <> 0 then
    begin
      GetMem(VerInfo, VerInfoSize);

      try
        If GetFileVersionInfo(Filename, 0, VerInfoSize,VerInfo) then
          If VerQueryValue(VerInfo, '\', Pointer(VerValue), VerValueSize) then
            begin
              Result.Major   := VerValue^.dwFileVersionMS shr 16;
              Result.Minor   := VerValue^.dwFileVersionMS and $FFFF;
              Result.Release := VerValue^.dwFileVersionLS shr 16;
              Result.Build   := VerValue^.dwFileVersionLS and $FFFF;
            end;
      finally
        FreeMem(VerInfo, VerInfoSize);
      end;
    end;
end;

procedure TForm2.Button1Click(Sender: TObject);
var
   S : String;
   VersionInfo: TVersionInfo;

begin
   VersionInfo := GetFileVersion(PWideChar(Application.ExeName));

   S := Format('Copyright by me!' + #13 + 'Version: %d.%d.%d.%d',
               [VersionInfo.Major, VersionInfo.Minor, VersionInfo.Release, VersionInfo.Build]);

   ShellAbout(self.Handle, PWideChar(Text), PWideChar(S), Application.Icon.Handle);
end;

end.

[DeddyH]

Verpasse ich irgendetwas, oder redet Ihr an einander vorbei? Was soll denn nun angezeigt werden, die Windows-Version oder die Versionsinfos des eigenen Programms?

[EWeiss]

Zitat:

Zitat von DeddyH (Beitrag 1312466)

Verpasse ich irgendetwas, oder redet Ihr an einander vorbei? Was soll denn nun angezeigt werden, die Windows-Version oder die Versionsinfos des eigenen Programms?

Denke auch..
Der Beitrag von hathor ist relevant.
Wie auch immer ;)

Zitat:

Hallo Hathor, dass klappt auch, danke.

Und auch nur das dein Lösungsansatz.

gruss

[Helmi]

Zitat:

Zitat von DeddyH (Beitrag 1312466)

Verpasse ich irgendetwas, oder redet Ihr an einander vorbei? Was soll denn nun angezeigt werden, die Windows-Version oder die Versionsinfos des eigenen Programms?

Ich kenn nur den Dialog über ShellAbout
und der zeigt ja die Windoof-Version an + einen eigenen Text (bei mir die eigene Programmversion)

zeigt nur den Windows-Text an - sonst gar nix - echt - gar nix: :mrgreen:

Delphi-Quellcode:

procedure TForm2.Button1Click(Sender: TObject);
begin
  ShellAbout(self.Handle, PWideChar(''), PWideChar(''), 0);
end;

[DeddyH]

Zitat:

Zitat von EWeiss (Beitrag 1312468)

Zitat:

Hallo Hathor, dass klappt auch, danke.

Und auch nur das dein Lösungsansatz.

U.U. stimmen die Parametertypen aber nicht, je nach Delphi-Version.
ShellExecuteA -> PAnsiChar
ShellExecuteW -> PWideChar
ShellExecute -> PChar

[jaenicke]

Zitat:

Zitat von Willie1 (Beitrag 1312459)

Nachtrag:
Meine Begeisterung für eine About-Box (ShellAbout) mit Windows lässt schnell nach. Unter Windows 10 wird Text in der Kopfzeile stur ignoriert (immer nur Info) und es wird dann die falsche Windows-Version angezeigt Version 6.2 (Built 9200) also Windows 8.

Du musst in deinem Anwendungsmanifest angeben, dass deine Anwendung mit Windows 10 kompatibel ist, dann wird auch alles korrekt angezeigt.

Da war Microsoft wohl etwas zu gründlich beim Umbiegen der Versionsfunktionen, so dass sie den eigenen Dialog betreffen.

[EWeiss]

Zitat:

Zitat von jaenicke (Beitrag 1312475)

Zitat:

Zitat von Willie1 (Beitrag 1312459)

Nachtrag:
Meine Begeisterung für eine About-Box (ShellAbout) mit Windows lässt schnell nach. Unter Windows 10 wird Text in der Kopfzeile stur ignoriert (immer nur Info) und es wird dann die falsche Windows-Version angezeigt Version 6.2 (Built 9200) also Windows 8.

Du musst in deinem Anwendungsmanifest angeben, dass deine Anwendung mit Windows 10 kompatibel ist, dann wird auch alles korrekt angezeigt.

Da war Microsoft wohl etwas zu gründlich beim Umbiegen der Versionsfunktionen, so dass sie den eigenen Dialog betreffen.

Wie ich vorhin noch gelesen habe gilt das mit GetVersionEx?
Sorry hab kein Win10.

GetVersionEx
Manifest

gruss

[hathor]

Zitat:

Zitat von DeddyH (Beitrag 1312473)

Zitat:

Zitat von EWeiss (Beitrag 1312468)

Zitat:

Hallo Hathor, dass klappt auch, danke.

Und auch nur das dein Lösungsansatz.

U.U. stimmen die Parametertypen aber nicht, je nach Delphi-Version.
ShellExecuteA -> PAnsiChar
ShellExecuteW -> PWideChar
ShellExecute -> PChar

Gelaber!

[Sir Rufo]

Bei UNICODE Delphis sollte die Verweise so stehen

Delphi-Quellcode:

function GetFileVersionInfoSize; external version name 'GetFileVersionInfoSizeW'; // <- da
function GetFileVersionInfoSizeA; external version name 'GetFileVersionInfoSizeA';
function GetFileVersionInfoSizeW; external version name 'GetFileVersionInfoSizeW';

und bei ANSI Delphis so

Delphi-Quellcode:

function GetFileVersionInfoSize; external version name 'GetFileVersionInfoSizeA'; // <- da
function GetFileVersionInfoSizeA; external version name 'GetFileVersionInfoSizeA';
function GetFileVersionInfoSizeW; external version name 'GetFileVersionInfoSizeW';

und schon ist die Welt wieder hübsch in Ordnung.

Nur wenn man explizit die ANSI oder UNICODE Variante haben möchte, dann muss man die auch aufrufen mit den richtigen Typen.

[Sir Rufo]

Es ist im Allgemeinen schon ratsam die Rückgabewerte der API Funktionen nicht nur zu prüfen, sondern auch die Exeptions werfen zu lassen.

Delphi-Quellcode:

function GetFileVersion( const AFileName: string ): TVersion; // <- selber definiert
var
  VersionInfoSize : DWORD;
  VersionInfo     : Pointer;
  VersionValueSize: DWORD;
  VersionValueData: PVSFixedFileInfo;
begin
  VersionInfoSize := CheckApiNotZero(
    netAlike.Winapi.Windows.GetFileVersionInfoSize( PChar( AFileName ), nil ), // <- selber richtig deklariert
    'GetFileVersionInfoSize( %s )', [ AFileName ] );
  GetMem( VersionInfo, VersionInfoSize );
  try
    CheckApiResult(
      GetFileVersionInfo( PChar( AFileName ), 0, VersionInfoSize, VersionInfo ),
      'GetFileVersionInfo( %s )', [ AFileName ] );
    CheckApiResult(
      VerQueryValue( VersionInfo, '\', Pointer( VersionValueData ), VersionValueSize ),
      'VerQueryValue( %s, "\" )', [ AFileName ] );
    Result := TVersion.CreateFromMSLS( VersionValueData.dwFileVersionMS, VersionValueData.dwFileVersionLS ); // <- dann wird das auch leichter
  finally
    FreeMem( VersionInfo, VersionInfoSize );
  end;
end;

procedure CheckApiResult( ApiCallResult: BOOL; const AdditionalInfo: string; const Args: array of const ); overload;
begin
  if not ApiCallResult
  then
    RaiseLastOSError( GetLastError, string.Format( sLineBreak + AdditionalInfo, Args ) );
end;

procedure CheckApiResult( ApiCallResult: BOOL; const AdditionalInfo: string );
begin
  CheckApiResult( ApiCallResult, AdditionalInfo, [ ] );
end;

function CheckApiNotZero( ApiCallResult: DWORD; const AdditionalInfo: string; const Args: array of const ): DWORD; overload;
begin
  if ApiCallResult = 0
  then
    RaiseLastOSError( GetLastError, string.Format( sLineBreak + AdditionalInfo, Args ) );
  Result := ApiCallResult;
end;

function CheckApiNotZero( ApiCallResult: DWORD; const AdditionalInfo: string ): DWORD;
begin
  Result := CheckApiNotZero( ApiCallResult, AdditionalInfo, [ ] );
end;

Wenn es jetzt knallt, bekommt man auch noch direkt mit, welcher Aufruf zickt.

Wer das mit den Zusatzinfos nicht benötigt, bekommt dadurch ein sehr kurze und übersichtliche Routine:

Delphi-Quellcode:

function GetFileVersion( const AFileName: string ): TVersion; // <- selber definiert
var
  VersionInfoSize : DWORD;
  VersionInfo     : Pointer;
  VersionValueSize: DWORD;
  VersionValueData: PVSFixedFileInfo;
begin
  VersionInfoSize := CheckApiNotZero( netAlike.Winapi.Windows.GetFileVersionInfoSize( PChar( AFileName ), nil ) );
  GetMem( VersionInfo, VersionInfoSize );
  try
    CheckApiResult( GetFileVersionInfo( PChar( AFileName ), 0, VersionInfoSize, VersionInfo ) );
    CheckApiResult( VerQueryValue( VersionInfo, '\', Pointer( VersionValueData ), VersionValueSize ) );
    Result := TVersion.CreateFromMSLS( VersionValueData.dwFileVersionMS, VersionValueData.dwFileVersionLS ); // <- dann wird das auch leichter
  finally
    FreeMem( VersionInfo, VersionInfoSize );
  end;
end;

[DeddyH]

Zitat:

Zitat von hathor (Beitrag 1312484)

Zitat:

Zitat von DeddyH (Beitrag 1312473)

Zitat:

Zitat von EWeiss (Beitrag 1312468)

Zitat:

Hallo Hathor, dass klappt auch, danke.

Und auch nur das dein Lösungsansatz.

U.U. stimmen die Parametertypen aber nicht, je nach Delphi-Version.
ShellExecuteA -> PAnsiChar
ShellExecuteW -> PWideChar
ShellExecute -> PChar

Gelaber!

Dann mach dasselbe doch mal mit Delphi <= 2007.

[Sir Rufo]

Zitat:

Zitat von DeddyH (Beitrag 1312520)

Dann mach dasselbe doch mal mit Delphi <= 2007.

Kann man bei Delphi vor der Version 2007 das hier nicht schreiben?

Delphi-Quellcode:

function GetFileVersionInfoSize; external version name 'GetFileVersionInfoSizeA';

Wäre mir jetzt neu ...

[DeddyH]

Und das hat genau was mit meinem Post zu tun? ShellExecute ist in Delphi <= 2007 als ShellExecuteA deklariert und erwartet PAnsiChar-Parameter (entspricht PChar in diesen Versionen). Ab Delphi 2009 ist es ShellExecuteW mit PWideChar-Parametern (entspricht dann hier PChar). Der Compiler weiß natürlich, von welchem Ursprungstyp PChar ist und zeigt diesen dann im Hint an. Von daher hat der gepostete Screenshot keine "Beweiskraft".

[Sir Rufo]

Wenn man es vernünftig haben will, dann nimmt erstellt man sich eine Unit, wo man a) die Api-Aufrufe korrekt deklariert und b) UNICODE / ANSI safe ist.

So sähe das dann aus:

Delphi-Quellcode:

unit myWindows,

interface

uses
  Windows;

type
  LPCTSTR = PChar;
  LPCSTR = PAnsiChar;
  LPCWSTR = PWideChar;

{$EXTERNALSYM GetFileVersionInfoSize}
function GetFileVersionInfoSize(lptstrFilename: LPCTSTR; lpdwHandle: LPDWORD): DWORD; stdcall;
{$EXTERNALSYM GetFileVersionInfoSizeA}
function GetFileVersionInfoSizeA(lptstrFilename: LPCSTR; lpdwHandle: LPDWORD): DWORD; stdcall;
{$EXTERNALSYM GetFileVersionInfoSizeW}
function GetFileVersionInfoSizeW(lptstrFilename: LPCWSTR; lpdwHandle: LPDWORD): DWORD; stdcall;

implementation

function GetFileVersionInfoSize; external version name {$IFDEF UNICODE} 'GetFileVersionInfoSizeW' {$ELSE} 'GetFileVersionInfoSizeA' {$ENDIF};
function GetFileVersionInfoSizeA; external version name 'GetFileVersionInfoSizeA';
function GetFileVersionInfoSizeW; external version name 'GetFileVersionInfoSizeW';

end.

Das dieses so in den Delphi-Versionen vor Delphi 2007 nicht gemacht wurde, dafür kann ich auch nichts, aber man hat es eben selber in der Hand, ob man es vernünftig, korrekt und sicher hat ;)

[DeddyH]

Aber auch dann muss man die richtigen Parametertypen verwenden.

[Sir Rufo]

Zitat:

Zitat von DeddyH (Beitrag 1312532)

Aber auch dann muss man die richtigen Parametertypen verwenden.

Ja, immer den richtigen, je nachdem welche Version ich brauche:

• Das was die Entwicklungsumgebung kann:
  Delphi-Quellcode:

  GetFileVersionInfoSize

  -> nimm
  Delphi-Quellcode:

  PChar

• Ich will UNICODE:
  Delphi-Quellcode:

  GetFileVersionInfoSizeW

  -> nimm
  Delphi-Quellcode:

  PWideChar

• Ich will ANSI:
  Delphi-Quellcode:

  GetFileVersionInfoSizeA

  -> nimm
  Delphi-Quellcode:

  PAnsiChar

Update
Genau das steht auch in der MSDN-Doku zum Datentyp LPCTSTR

Zitat:

LPCTSTR

An LPCWSTR if UNICODE is defined, an LPCSTR otherwise. For more information, see Windows Data Types for Strings.

This type is declared in WinNT.h as follows:

Code:

#ifdef UNICODE
 typedef LPCWSTR LPCTSTR; 
#else
 typedef LPCSTR LPCTSTR;
#endif

Somit ist also

Delphi-Quellcode:

type
  LPCTSTR = PChar;
  LPCSTR  = PAnsiChar;
  LPCWSTR = PWideChar;

[DeddyH]

Das ist doch exakt das, was ich vorher gesagt habe und was als Quatsch abgetan wurde, weil die IDE im Hint ja den Ursprungstypen anzeigt. Wir drehen uns im Kreis.

[Sir Rufo]

Zitat:

Zitat von DeddyH (Beitrag 1312539)

Das ist doch exakt das, was ich vorher gesagt habe und was als Quatsch abgetan wurde, weil die IDE im Hint ja den Ursprungstypen anzeigt. Wir drehen uns im Kreis.

Du sagst, mann muss bei den Delphi-Versionen aufpassen, und wir sagen, das ist Quatsch, wenn man es richtig definiert hat, dann definiert sich das durch die Verwendung von

Delphi-Quellcode:

PChar

und

Delphi-Quellcode:

GetFileVersionSize

von ganz alleine.

[DeddyH]

Zitat:

Zitat von Sir Rufo (Beitrag 1312540)

Du sagst, mann muss bei den Delphi-Versionen aufpassen, ...

Wo soll ich das denn gesagt haben?

[Sir Rufo]

Zitat:

Zitat von DeddyH (Beitrag 1312541)

Zitat:

Zitat von Sir Rufo (Beitrag 1312540)

Du sagst, mann muss bei den Delphi-Versionen aufpassen, ...

Wo soll ich das denn gesagt haben?

Uppps, ich glaube ich habe da den Kontext deiner Beanstandung verwechselt. Du hast dich wohl auf den Beitrag

Zitat:

Zitat von hathor (Beitrag 1312372)

Parameter von WINVER.exe gibt es bis WIN8.1 nicht.

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var  strParams,FN : String;
begin                                          // uses Winapi.ShellAPI
 strParams:= ''; // für Programme MIT Parameter
 FN:='winver.exe';
ShellExecute(Application.Handle,NIL,PWChar(FN), PWChar(strParams),NIL, SW_Normal);
end;

bezogen, und das ist definitiv falsch, womit du natürlich recht hast.

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var  strParams,FN : String;
begin                                          // uses Winapi.ShellAPI
 strParams:= ''; // für Programme MIT Parameter
 FN:='winver.exe';
ShellExecute( Application.Handle, NIL, {PWChar ist hier FALSCH}PChar(FN), {PWChar}PChar(strParams), NIL, SW_Normal );
end;

[DeddyH]

Jetzt sind wir uns endlich einig :thumb:. Der Hinweis mit der Delphi-Version bezog sich auf den Screenshot.

[hathor]

Was ist das hier eigentlich?
Eine Hetzjagd?
SCHEISSGELABER !!!
Gibt es hier keinen Moderator, der den ganzen Scheiss mal rauswirft???!!!

[Sir Rufo]

Also uns geht es um die Fakten und die sachliche Richtigkeit.

Worum geht es dir? Ruhm, Ehre, Anerkennung, ... :gruebel:

[Willie1]

Hallo Leute,
der Ausgangspunkt meiner Frage war, eine About-Box für meine eigenen Programme. In dieser zeige ich zusätzlich meine eigene Ikone, die Windows-Version und die Größe des Arbeitsspeichers.
Ab Windows 8.1 lässt die Version nicht mehr mit GetWindowsVersion und seit W 10 auch nicht mehr über die Registry abfragen.
Meine Idee war ein Button auf der About-Box, mit der sich das Windows-Info Fenster öffnen lässt. (Bei Vista wird hier auch der Arbeitsspeicher angezeigt, nicht bei W 10).
Da kam mir Helmis Vorschlag mit ShellAbout gerade recht: About-Box Und Windows-Info zusammen! Ich stelle aber fest, dass Win 10 den individuellen Kopftext ignoriert und die
falsche Windows Version 6.2 9200 anzeigt. Wenn ich die Lösung von Hathor nehme, wird dagegen die richtige Version 10.0.10240 angezeigt.
Ihr könnt es ausprobieren.
Willie.

[DeddyH]

Darum ging es uns auch gar nicht, sondern um die falschen Parametertypen. Schau Dir doch die korrigierte Fassung aus #26 noch einmal an.

[Dalai]

Zitat:

Zitat von Willie1 (Beitrag 1312560)

Ich stelle aber fest, dass Win 10 den individuellen Kopftext ignoriert und die falsche Windows Version 6.2 9200 anzeigt.

Jo mei, dann integrier doch ein passendes Manifest und fertig. Das sollte man sowieso machen. Ja, am Anfang mag das vielleicht kompliziert klingen und ggf. auch sein, aber wenn man das einige Male gemacht hat, geht das sehr leicht von der Hand und man will nicht mehr ohne. Es gibt da einerseits einige Anleitungen im Netz dafür und andererseits gibt's den Manifest Creator von himitsu hier im Forum (einfach mal nach Manifest Creator suchen), auch wenn ich mir grad nicht sicher bin, ob der bereits die Kompatibilität zu Win10 erzeugen kann (denke aber schon).

Zitat:

Wenn ich die Lösung von Hathor nehme, wird dagegen die richtige Version 10.0.10240 angezeigt.
Ihr könnt es ausprobieren.

Logisch, weil dort einfach die winver.exe aufgerufen wird, und die kennt das Windows natürlich.

MfG Dalai

[EWeiss]

Zitat:

Ab Windows 8.1 lässt die Version nicht mehr mit GetWindowsVersion und seit W 10 auch nicht mehr über die Registry abfragen.

OK dann.
Deshalb sollte/könnte man auch das hier nehmen.

GetVersionEx
http://securityblog.gr/2617/get-wind...-service-pack/

gruss

[Sir Rufo]

Es funktioniert wunderbar, wenn man sich die Version von "kernel32.dll" beschafft.

Delphi-Quellcode:

AppVersion := GetFileVersion( ParamStr(0) );
WinVersion := GetFileVersion( 'kernel32.dll' ); // liefert die echte Windows-Version

[Willie1]

Hallo Dalai,
ich will's nicht so oft erwähnen, ich sehe schlecht und bin nur Hobby-Programmierer..
Ich habe die Seite bei MS gefunden und weiß jetzt, dass GetWindowsVersion ausgeknipst ist:https://msdn.microsoft.com/en-us/lib...=vs.85%29.aspx
Mit dem Manifest-Beispiel komme ich aber nicht zurecht, da fehlen mir die Grundlagen.
Die weiteren Lösungen werde ich am anderen Rechner mit Delphi ausprobieren.
Willie.

[Dalai]

Zitat:

Zitat von Willie1 (Beitrag 1312581)

Ich habe die Seite bei MS gefunden und weiß jetzt, dass GetWindowsVersion ausgeknipst ist:https://msdn.microsoft.com/en-us/lib...=vs.85%29.aspx

Naja, ausgeknipst ist es nicht, nur als "Deprecated", also "veraltet", markiert und sie liefert ohne passende Kompatibilität eine ältere/falsche Version zurück.

Zitat:

Mit dem Manifest-Beispiel komme ich aber nicht zurecht, da fehlen mir die Grundlagen.

Daher mein Hinweis auf die diversen Anleitungen im Netz (darunter natürlich auch deutschsprachige) und himitsus Manifest Creator hier im Forum. Letztlich ist die Manifest-Geschichte halb so wild.

MfG Dalai

[t.roller]

Interessant mit Sourcecode:
http://www.winsoft.sk/download/osversion.zip
http://www.winsoft.sk/download/osversion.exe

[a.def]

Oder hier: [Kompo] TWindowsVersionsInfo - Kompo zur Windowserkennung

[Luckie]

Es ist die Frage wozu man es braucht. Nur zum Anzeigen kann man wohl die Version von der kernel32.dll nehmen. Will man aber sicherstellen, dass das Programm auch unter der angestrebten Windows Version lauffähig ist, sollte man gegen VerifyVersionInfo https://msdn.microsoft.com/en-us/lib...(v=vs.85).aspx testen.

[Willie1]

Hallo,
bei Delphi 10 Berlin liefert TOSVersion.ToString Windows 10(Version 10.0 Build 0 64-Bit-Edition) zurück. Schon besser aber nicht gut!
TOSVersion.Check(6,3) gibt true zurück bei Windows 10. Gut!
Ich habe gerade festgestellt, es ist völlig egal welche Werte ich eingebe z.B 0,0 oder 8,0, es ergibt immer true.

Aber wenn der Programmierer mit dem Manifest selbst bestimmt, welche Version es sein soll, ist eine Abfrage wohl tatsächlich unnötig. Ich verstehe die Absicht von Microsoft nicht!

Gruß Willie