Office 2010 - Click-To-Run - Installation erkennen

[Walter Landwehr]

Hallo,

ich löse das so:

Delphi-Quellcode:

function WordVersion: Double;
begin
  Result := 0.0;
  with TRegistry.Create do
  begin
    try
      if (KeyExists('Software\Microsoft') = True) then
      begin
        OpenKeyReadOnly('Software\Microsoft');
        if (KeyExists('Word\7.0') = True) then  // Office 95
              Result := 7.0
      else
        if (KeyExists('Office') = True) then
        begin
          OpenKeyReadOnly('Office');
          if (KeyExists('8.0\Word') = True) then     // Office 97
             Result := 8.0
          else
             if (KeyExists('9.0\Word') = True) then   // Office 2001
               Result := 9.0
          else
             if (KeyExists('10.0\Word') = True) then  // Office XP
               Result := 10.0
          else
             if (KeyExists('11.0\Word') = True) then  // Office 2003
               Result := 11.0
          else
             if (KeyExists('12.0\Word') = True) then  // Office 2007
               Result := 12.0
          else
             if (KeyExists('14.0\Word') = True) then  // Office 2011
               Result := 14.0
          else
             if (KeyExists('15.0\Word') = True) then  // Office 2013
               Result := 15.0;
        end;
      end
    finally
           Free;
      end;
  end;
end;

[Sir Rufo]

Warum das?
if (KeyExists('Software\Microsoft') = True) then Mal in Worten gefasst

Code:

Wenn die Bedingung wahr ist nicht falsch ist dann

Ein einfaches
if KeyExists('Software\Microsoft') then reicht völlig aus, ist besser zu lesen und liefert auch zuverlässig die richtige Reaktion, denn

Delphi-Quellcode:

const // definiert in Delphi
  False := 0;
  True := 1;

Aber bei if wird der then dann aufgerufen, wenn die Bedingung nicht falsch (<> false => <> 0 ) ist.
Dadurch funktioniert das auch, wenn eine Funktion als Boolean etwas anderes als 1 zurückliefert (beliebt ist auch -1). Deine Abfrage würde jetzt aber scheitern, denn du prüfst ja ganz gezielt auf 1 ab.

[RWarnecke]

Die Funktion WordVersion liefert aber nicht zuverlässig die Version. Auf einem 64Bit Betriebssystem und ein Office 2010 64Bit wird nicht erkannt, außer ich kompiliere es als 64Bit Anwendung.

[himitsu]

Pssst, ab dem ersten Else, bis zum Finally, gehört alles irgendwie bissl nach Rechts, denn dieses Else gehört zu dem, was man jetzt denken könnte.
(aber über Formatierung kann man ja bekanntlich streiten)
Single würde ja auch schon reichen, bei den kleinen Werten, wobei hier sogar ein Integer passen würde, da es ja (aktuell) keine Nachkommastellen gibt, wobei sich ein Integer aber "sicherer" vergleichen lässt.

Und OpenKeyReadOnly hat einen Rückgabewert, in dem das KeyExists schon eingebaut ist.

Zitat von RWarnecke:

Die Funktion WordVersion liefert aber nicht zuverlässig die Version. Auf einem 64Bit Betriebssystem und ein Office 2010 64Bit wird nicht erkannt, außer ich kompiliere es als 64Bit Anwendung.

Gab es da nicht einen Befehl, welcher diese Umleitung deaktiviert?

Ansonsten fängt man ja an:
- 32 Bit-Windows mit 32 Bit-Word
- 64 Bit-Windows mit 64 Bit-Word
- 64 Bit-Windows mit 32 Bit-Word

Delphi-Quellcode:

// Wenn ich dein Muster der Formatierung konsequennt versucht weiterzuverfolgen, dann lande ich hier.
function WordVersion: Integer;
begin
  Result := 0;
  with TRegistry.Create do
    try
      if OpenKeyReadOnly('Software\Microsoft') then
        if KeyExists('Word\7.0') then // Office 95
          Result := 7
        else
          if OpenKeyReadOnly('Office') then
            if KeyExists('8.0\Word') then // Office 97
              Result := 8
            else
              if KeyExists('9.0\Word') then // Office 2001
                Result := 9
            else
              if KeyExists('10.0\Word') then // Office XP
                Result := 10
            else
              if KeyExists('11.0\Word') then // Office 2003
                Result := 11
            else
              if KeyExists('12.0\Word') then // Office 2007
                Result := 12
            else
              if KeyExists('14.0\Word') then // Office 2011
                Result := 14
            else
              if KeyExists('15.0\Word') then // Office 2013
                Result := 15;
    finally
      Free;
    end;
end;


// Oder man zieht alle IFs auf die selbe Ebene, welche als ELSE-IF zusammenhängen.
function WordVersion: Integer;
begin
  Result := 0;
  with TRegistry.Create do
    try
      if OpenKeyReadOnly('Software\Microsoft') then
        if KeyExists('Word\7.0') then // Office 95
          Result := 7
        else
        if OpenKeyReadOnly('Office') then
          if KeyExists('8.0\Word') then // Office 97
            Result := 8
          else
          if KeyExists('9.0\Word') then // Office 2001
            Result := 9
          else
          if KeyExists('10.0\Word') then // Office XP
            Result := 10
          else
          if KeyExists('11.0\Word') then // Office 2003
            Result := 11
          else
          if KeyExists('12.0\Word') then // Office 2007
            Result := 12
          else
          if KeyExists('14.0\Word') then // Office 2011
            Result := 14
          else
          if KeyExists('15.0\Word') then // Office 2013
            Result := 15;
    finally
      Free;
    end;
end;


// Wenn man die nun auch wieder entsprechend dem ELSE aufteilt und das ELSE-IF nicht zusammenhängend sieht, dann sieht das schnell so aus.
// Denn so, wie im Beispiel 1 (welches deiner Vorlage entsprach), würden sonst die ELSE vom IF scheinbar eine Ebene wegrutschen.
function WordVersion: Integer;
begin
  Result := 0;
  with TRegistry.Create do
    try
      if OpenKeyReadOnly('Software\Microsoft') then
        if KeyExists('Word\7.0') then // Office 95
          Result := 7
        else
          if OpenKeyReadOnly('Office') then
            if KeyExists('8.0\Word') then // Office 97
              Result := 8
            else
              if KeyExists('9.0\Word') then // Office 2001
                Result := 9
              else
                if KeyExists('10.0\Word') then // Office XP
                  Result := 10
                else
                  if KeyExists('11.0\Word') then // Office 2003
                    Result := 11
                  else
                    if KeyExists('12.0\Word') then // Office 2007
                      Result := 12
                    else
                      if KeyExists('14.0\Word') then // Office 2011
                        Result := 14
                      else
                        if KeyExists('15.0\Word') then // Office 2013
                          Result := 15;
    finally
      Free;
    end;
end;


// Während ich die ELSE-IF dann doch lieber auch zusammenhänge. Quasi so, als gäbe es auch im Delphi einen zusammenhängenden Elseif-Befehl.
// Denn dann kann man die Einrückung wieder problemlos konsequennt durchziehen.
function WordVersion: Integer;
begin
  Result := 0;
  with TRegistry.Create do
    try
      if OpenKeyReadOnly('Software\Microsoft') then
        if KeyExists('Word\7.0') then // Office 95
          Result := 7
        else if OpenKeyReadOnly('Office') then
          if KeyExists('8.0\Word') then // Office 97
            Result := 8
          else if KeyExists('9.0\Word') then // Office 2001
            Result := 9
          else if KeyExists('10.0\Word') then // Office XP
            Result := 10
          else if KeyExists('11.0\Word') then // Office 2003
            Result := 11
          else if KeyExists('12.0\Word') then // Office 2007
            Result := 12
          else if KeyExists('14.0\Word') then // Office 2011
            Result := 14
          else if KeyExists('15.0\Word') then // Office 2013
            Result := 15;
    finally
      Free;
    end;
end;

[Sir Rufo]

Generell stellt sich mir die Frage, was man mit dieser Information denn nun anfangen möchte?

In den seltensten Fällen, möchte man ja nur diese Versionsnummer anzeigen.
Der Grund für die Abfrage ist mir schon klar, denn jede Version hat so seine Eigenarten, die man dann auch berücksichtigen muss.

Aber will ich denn wirklich in dem produzierenden Code ständig diese Fallunterscheidungen machen?
Da wäre es doch besser ich habe eine abstrakte Klasse, die für die Erstellung eines Dokuments zuständig ist.
Für jede Office- Version gibt es eine Ableitung (insofern das denn auch notwendig ist).

Dann hole ich mir über eine Factory abhängig von der Office-Version eine passende Instanz und benutze diese. Diese Factory kann dann eine Exception werfen, wenn es keine oder keine unterstützte Office-Version findet. Alternativ könnte aber auch eine Instanz geliefert werden, die dann z.B. ein RTF-Dokument (oder was auch immer) erstellt.

BTW

Die beste Methode um die installierte Version zu ermitteln ist:

Delphi-Quellcode:

function GetInstalledWordVersion : integer;
var
  LWord : OleVariant;
begin
  LWord := CreateOleObject( 'Word.Application' );
  try
    Result := LWord.Version;
  finally
    LWord := Unassigned;
  end;
end;

PS: Die "Click-To-Run" können per OLE-Automatisierung nicht angesprochen werden