"Version Compare" / Major/Minorversion Vergleich

[slemke76]

Hallo zusammen,

ich möchte gerne sicher gehen, dass meine Anwendung (mindestens) gegen eine bestimmte Indy-Version compiliert ist - auch um versehntlich nicht auf die mitgelieferte Version "zurückzufallen".
Da gibt es die MajorVersion, MinorVersion, Release und Build Angabe in der IdVers.inc.

Unter PHP gibt es so eine prima Vergleichsfunktion: http://php.net/manual/de/function.version-compare.php
Gibt es etwas ähnliches unter Delphi?

Oder muss ich so etwas machen und in einer {$IF} Bedingung vergleichen?
(gsIdVersionMajor*1000*1000*1000)+(gsIdVersionMino r*1000*1000)+(gsIdVersionRelease*1000)+gsIdVersion Build => meinegewünschteversion

lg
Sebastian

[Dalai]

Multiplikation hab ich früher auch mal benutzt. Später bin ich auf eine Funktion _VersionCompare() im AutoIt gestoßen, die zwar recht lang ist, aber der Code ist gut verständlich. Die Funktion bekommt zwei Parameter (die zu vergleichenden Versionen), die an den darin enthaltenen Punkten gesplittet werden. Verglichen werden dann einfach die Einzelteile, und ein Abbruch erfolgt, sobald eine Ungleichheit gefunden wurde. Die Funktion fällt auf Stringvergleich zurück, sollte das nötig sein (eine Stelle bzw. ein Parameter kein Ordinalwert).

Sowas sollte sich in Delphi analog umsetzen lassen. Bei Interesse einfach mal AutoIt runterladen (ZIP genügt), und einen Blick in Include\Misc.au3 werfen. Auch als Nicht-AutoItler sollte man sich im Code zurechtfinden.

Grüße
Dalai

[Ghostwalker]

Hier mal meine Lösung:

Delphi-Quellcode:

unit Unit10;

interface
uses
  System.Classes,System.SysUtils;

Type
  TVersion = record
    private
      fmajor,fminor,frelease,fbuild : Integer;
    public
      property Major:integer read fmajor write fmajor;
      property Minor:integer read fminor write fminor;
      property Release:integer read frelease write frelease;
      Property Build:integer read fbuild write fbuild;

      Procedure SetVersion(major,minor,release,build:integer);
      Procedure FromString(VersionStr:string);
      function isEqualTo(Versionstr:string):boolean;

  end;
implementation

procedure TVersion.FromString(VersionStr: string);
var
  str : TStrings;

begin
  str := TStringlist.Create;
  str.Delimiter := '.';
  str.DelimitedText := VersionStr;
  fmajor := StrToInt(str.Strings[0]);
  fminor := StrToInt(str.Strings[1]);
  frelease := StrToInt(str.strings[2]);
  fbuild := StrToInt(str.Strings[3]);
  str.Free;
end;

function TVersion.isEqualTo(Versionstr: string):boolean;
var
  str : TStrings;
  hlp : integer;
begin
  str := Tstringlist.Create;
  str.Delimiter := '.';
  str.DelimitedText := VersionStr;
  result := false;
  hlp := StrToInt(str.Strings[0]);
  if (hlp = fmajor) then
  begin
    hlp := StrToInt(str.Strings[1]);
    if (hlp = fminor) then
    begin
      hlp := StrToInt(str.Strings[2]);
      if (hlp = frelease) then
      begin
        hlp := StrToInt(str.Strings[3]);
        if (hlp = fbuild) then
          result := true;
      end;
    end;
  end;
  str.Free;
end;

procedure TVersion.SetVersion(major: Integer; minor: Integer; release: Integer; build: Integer);
begin
  fmajor := major;
  fminor := minor;
  frelease : release;
  fbuild := build;
end;
end.

Anwendung:

Delphi-Quellcode:

  :
  const cDesiredVersion = '10.12.13.1294';
  : 
  var vers : TVersion;
  :
  begin
    vers.FromString(cDesiredVersion);
    if (vers.isEqualTo(gsIdVersion)) then
      //wenn die Version passt
    else
     //wenn die Version nicht passt
  end;

Das ganze funktioniert zur Laufzeit (also wenn das Programm schon compiliert wurde).

Um das compilieren mit einer falschen Version zu unterbinden musst du den Weg über $IF gehen.

[Bernhard Geyer]

Bedenke das auch Versionnummern mit Buchstaben möglich sind.
Also 12.1.15b

[Ghostwalker]

Da hast du Recht. Die notwendigen Anpassungen sollten aber nicht wirklich das große Problem sein :)

[himitsu]

Wäre es nicht ganz einfach, wenn man einach nur ein NaturalCompare, oder wie man das immer nennen mag, nutzt?
Also wo Zahlen wir Zahlen und nicht als Strings verglichen werden, so wie bei der Sortierung im Explorer.

Und schon ist es egal wieviele Punkte/Nummern oder ob Buchstaben.
Eventuell noch die Leerzeichen ignorieren, bzw. durch Punkte ersetzen und doppelte Punkte entfernen.

[slemke76]

Hallo zusammen,

vielen Dank für die Anregungen - die Lösung aus dem AutoIT gefällt mir ab besten, da man nicht nur den exakten Vergleich sondern auch kleiner/größer machen könnte.

Ein Naturalcompare wird vermutlich bei diesem Beispiel nicht korrekt funktionieren: 10.6.2 gegen 10.10.2 - da wird die 10.10 als "älter" erkannt, da 1 vor 6 sortiert wird. Oder täusche ich mich jetzt?

Da ich derjenige bin, der das Program compiliert, möchte ich auch gerne die Meldung beim compilieren haben - eine Ausgabe zur Laufzeit (irgendwo in einer Unit, die man womöglich nicht jedesmal neu durchtestet) könnte man (= ich) übersehen ;-)

Ich habe es jetzt mehrere Lösungen, die ich nicht vorenthalten möchte:

Delphi-Quellcode:

{$i IdCompilerDefines.inc}

{$IFNDEF INDY100}
  {$MESSAGE Error 'This project must be compiled against Indy 10'}
{$ENDIF}
{$IFNDEF 10_6_2}
  {$MESSAGE Error 'This project must be compiled against Indy 10.6.2'}
{$ENDIF}

Wobei ich die Benennung von "10_6_2" unglücklich finde - "INDY10_6_2" wäre wohl besser gewesen, zumal folgende Bedingung nicht funktioniert: {$IF not Defined(INDY100) or not Defined(10_6_2)}

Das ganze macht natürlich nur einen exakten Vergleich - das ist etwas unglücklich, deswegen habe ich das anders gelöst - zuerst habe ich noch Multipliziert, aber dann bitweise verschoben und verknüpft - auch wenn nicht relevant bei heuten CPUs sicherlich die schnellste Lösung:

Delphi-Quellcode:

const
  {$i IdVers.inc}

  gsIdMinVersionMajor = 10;
  gsIdMinVersionMinor = 6;
  gsIdMinVersionRelease = 2;

  gsIdActualBitwise = ( gsIdVersionMajor shl 20) OR ( gsIdVersionMinor shl 10) OR gsIdVersionRelease;
  gsIdMinimumBitwise = ( gsIdMinVersionMajor shl 20 ) OR ( gsIdMinVersionMinor shl 10 ) OR gsIdMinVersionRelease;

{$IF not Declared(gsIdActualBitwise) or ( gsIdActualBitwise < gsIdMinimumBitwise )}
  {$MESSAGE Error 'Indy Version is too old.'}
{$IFEND}

Ich hoffe, es hilft irgendwann einmal jemanden ;-)

Grüße
Sebastian

[himitsu]

Statt Integern vielleicht mit Floats?

major.minor
major.minorxyz

1.2.3.4

1.020304

CompilerVersion

[slemke76]

Hallo,

kann nicht ganz folgen, stehe auf dem Schlauch ;-) Bekommt man das schöner hin?

Die Definition, die von den Indys zur Verfügung steht sieht so aus: https://github.com/graemeg/indy/blob...tem/IdVers.inc

Sebastian

[Uwe Raabe]

Delphi-Quellcode:

{$IF (gsIdVersionMajor <> 10) or (gsIdVersionMinor <> 6) or (gsIdVersionRelease <> 2) or (gsIdVersionBuild <> 0)}
{$MESSAGE Fatal 'Falsche Indy-Version!'}
{$ENDIF}

[slemke76]

Hallo,

Zitat:

Zitat von Uwe Raabe (Beitrag 1395044)

Delphi-Quellcode:

{$IF (gsIdVersionMajor <> 10) or (gsIdVersionMinor <> 6) or (gsIdVersionRelease <> 2) or (gsIdVersionBuild <> 0)}
{$MESSAGE Fatal 'Falsche Indy-Version!'}
{$ENDIF}

Beim Update der Komponente auf eine neuere Version muss ich das anpassen, bei meiner Lösung nicht, da ist es ein Minimum- und kein Exaktes Requirement.

Grüße
Sebastian

[Uwe Raabe]

Zitat:

Zitat von slemke76 (Beitrag 1395047)

Beim Update der Komponente auf eine neuere Version muss ich das anpassen, bei meiner Lösung nicht, da ist es ein Minimum- und kein Exaktes Requirement.

Das mit dem "mindestens" hatte ich übersehen.

[himitsu]

Delphi-Quellcode:

{$IF (gsIdVersionMajor > 10) or ((gsIdVersionMajor = 10) and (gsIdVersionMinor > 6)) or ((gsIdVersionMajor = 10) and (gsIdVersionMinor = 6) and (gsIdVersionRelease > 2)) or ((gsIdVersionMajor = 10) and (gsIdVersionMinor = 6) and (gsIdVersionRelease = 2) and (gsIdVersionBuild >= 0))}

:stupid:

Nja, es gibt mehrere Varianten für das Gleiche.

Delphi-Quellcode:

gsIdVersion = '10.06.02.01';  // 00-09 mit führender 0 oder Leerzeichen, aber besser die 0
{$IF gsIdVersion >= '10.02.00.00'}
{$IF gsIdVersion >= '10.00.00.00'}

gsIdVersion = 10060201;
{$IF gsIdVersion >= 10020000}
{$IF gsIdVersion >= 10000000}

gsIdVersion = 10.060201;
{$IF gsIdVersion >= 10.02}
{$IF gsIdVersion >= 10}

Meistens interessieren Einen nur die erste oder die ersten beiden Stellen (Major und Minor),
da ist dann das Letztere halt einfacher/verständlicher.

Nachteil bei all diesen Dingen: Die subversionen dürfen nur Werte von 0 bis 99 haben.
Bei String darfs der Major auch nur 0 bis 99, aber dei den Numerischen kann es auch größer/kleiner sein.

[slemke76]

Hallo,

Zitat:

Zitat von Uwe Raabe (Beitrag 1395049)

Das mit dem "mindestens" hatte ich übersehen.

Alles gut, ich freue mich über das viele Feedback ;-)

@himitsu:
Ich sehe das tatsächlich in diesem Falle nicht ganz, die Definition von gsIdVersion kommt aus den Indys, da habe ich keinen Einfluss drauf:

Delphi-Quellcode:

gsIdVersion = '10.6.2.0'; {do not localize}

und da fehlen bei der Minorversion und dem Release die führende "0".

Grüße,
Sebastian

[himitsu]

OK, das bei Indy ist vorgegeben,

obwohl? :stupid:

Delphi-Quellcode:

const gsIdVersionNum = gsIdVersionMajor + (gsIdVersionMinor / 100) + (gsIdVersionRelease / 10000) + (gsIdVersionBuild / 1000000);
// oder
const gsIdVersionNum = (gsIdVersionMajor * 1000000) + (gsIdVersionMinor * 10000) + (gsIdVersionRelease * 100) + gsIdVersionBuild;

Es ging mehr allgemein um Aufbau/Verwendung von Versionnummern im Quelltext, speziell in Compiler-Direktiven, wo keine aufwändigen Stringvergleiche möglich sind.
Die String-Version von Indy kann wirklich nicht für einen Vergleich verwendet werden, also größer oder kleiner (außer auf Gleichheit).
Außer gsIdVersionMinor/gsIdVersionRelease/gsIdVersionBuild sind niemals größer als 9.

[himitsu]

Vorallem das Build ist ofrmals größer als 99. (viele Projekte zählen das seit Beginn kontinuierlich hoch)
In den Versionskonstanten stehen daher oftmals nur die ersten zwei oder drei Nummern. (mehr ist auch fast nie nötig)

PS: Und die VersionsInfo-Records im Windows bestehen aus WORDs.
word.word.word.word
00000000000000000000
00000.000000000000000
'00000.00000.00000.00000'

In der Versionsresource gibt es neben den beiden RECORDS (in der .RC ein String mit festem Format) auch nochmal zusätzlich die Versionen als "freier" String.

[slemke76]

Zitat:

Zitat von himitsu (Beitrag 1395056)

Es ging mehr allgemein um Aufbau/Verwendung von Versionnummern im Quelltext, speziell in Compiler-Direktiven, wo keine aufwändigen Stringvergleiche möglich sind.

Stimmt, ich hatte den speziellen Indy Fall im Blick. So hat sich aber ein prima Thread entwickelt, der vielleicht auch anderen noch mal weiterhelfen kann ;-)

Grüße
Sebastian

[mjustin]

Zitat:

Zitat von slemke76 (Beitrag 1395055)

die Definition von gsIdVersion kommt aus den Indys, da habe ich keinen Einfluss drauf:

Delphi-Quellcode:

gsIdVersion = '10.6.2.0'; {do not localize}

Lädt man den Indy Daily Build von indy.fulgan.com, sieht die Zeile anders aus: die IdVers.Inc enthält dort immer auch die Buildnummer. Im Subversion Repo hat sie immer den Wert 0.
Zum Beispiel in der aktuellen Indy10_5448.zip

Delphi-Quellcode:

gsIdVersion = '10.6.2.5448'; {do not localize}

Praktisch bedeutet dass, dass man Major/Minor und Release sicher vergleichen kann. Bei der Buildnummer kommt es darauf, an 'woher' die Indy Version kommt.