Détecter si Office est 32bit ou 64bit via le registre

j'ai testé la réponse D'Otaku et il semble que la valeur de bitness Outlook soit réglée même quand Outlook n'est pas installé, même si l'article référencé n'indique pas clairement que ce serait le cas.

pour ajouter à la réponse de vtrz, voici une fonction que J'ai écrite pour Inno Setup:

const
  { Constants for GetBinaryType return values. }
  SCS_32BIT_BINARY = 0;
  SCS_64BIT_BINARY = 6;
  { There are other values that GetBinaryType can return, but we're }
  { not interested in them. }

{ Declare Win32 function  }
function GetBinaryType(lpApplicationName: AnsiString; var lpBinaryType: Integer): Boolean;
external 'GetBinaryTypeA@kernel32.dll stdcall';

function Is64BitExcelFromRegisteredExe(): Boolean;
var
  excelPath: String;
  binaryType: Integer;
begin
  Result := False; { Default value - assume 32-bit unless proven otherwise. }
  { RegQueryStringValue second param is '' to get the (default) value for the key }
  { with no sub-key name, as described at }
  { http://stackoverflow.com/questions/913938/ }
  if IsWin64() and RegQueryStringValue(HKEY_LOCAL_MACHINE,
      'SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\excel.exe',
      '', excelPath) then begin
    { We've got the path to Excel. }
    try
      if GetBinaryType(excelPath, binaryType) then begin
        Result := (binaryType = SCS_64BIT_BINARY);
      end;
    except
      { Ignore - better just to assume it's 32-bit than to let the installation }
      { fail.  This could fail because the GetBinaryType function is not }
      { available.  I understand it's only available in Windows 2000 }
      { Professional onwards. }
    end;
  end;
end;

J'ai le Regret de le dire, mais les méthodes D'Otacku et de @clatonh ne fonctionnent pas pour moi.{90140000-0011-0000- 1000 - 0000000FF1CE} in registry (for 64-bit Office without Outlook installed).

la seule façon que j'ai trouvé, mais pas via le registre, est de vérifier bitness pour l'un des exécutables de bureau avec l'utilisation de la fonction API Windows GetBinaryType (depuis Windows 2000 Professionnel).

par exemple, vous pouvez vérifier le bitness de Winword.exe, dont le chemin est stocké sous

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\Winword.EXE.

voici le fragment de code MFC:

CRegKey rk;
if (ERROR_SUCCESS == rk.Open(HKEY_LOCAL_MACHINE, 
  "SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\Winword.exe", 
  KEY_READ)) {
    CString strWinwordPath;
    DWORD dwSize = MAX_PATH;
    if (ERROR_SUCCESS == rk.QueryStringValue(strWinwordPath, 
        strWinwordPath.GetBuffer(MAX_PATH), &dwSize)) {
            strWinwordPath.ReleaseBuffer();
            DWORD dwBinaryType;
            if (::GetBinaryType(strWinwordPath, &dwBinaryType)) {
                if (SCS_64BIT_BINARY == dwBinaryType) {
                    // Detected 64-bit Office 
                } else {
                    // Detected 32-bit Office 
                }
            } else {
                // Failed
            }
        } else {
            // Failed
        }
    } else {
    // Failed
}

Attention: en questionnant la bitness de L'application Outlook ne fonctionne pas de manière fiable si appelé dans l'environnement.net.

ici, nous utilisons GetBinaryType () dans une DLL qui peut être appelé par n'importe quelle application:

• si l'application hôte est 64 bits C/C++, getbinarytype() retourne SCS_32BIT_BINARY.
• si l'application hôte est 64 bit .NET (nous avons testé "AnyCPU" sur un système 64 bit)), Getbinarytype () retourne SCS_64BIT_BINARY.

avec exactement le même code DLL et exactement le même chemin binaire Outlook ("c:/Program Files (x86)/...") sur le même ordinateur.

signifie que vous pourriez avoir besoin de tester le fichier binaire vous-même en utilisant" IMAGE_NT_HEADERS.FileHeader.Machine d'entrée".

Dieu, je déteste les valeurs de retour incorrectes de certains API Windows (voir aussi GetVersion() lie).

j'ai trouvé cette approche:

si HKLM\Software\WOW6432Node existe alors Windows est 64-bit.

si HKLM\Software\WOW6432Node\Microsoft\Office existe, alors Office est de 32 bits.

si HKLM\Software\WOW6432Node\Microsoft\Office n'existe pas, mais HKLM\Software\Microsoft\Office existe, alors Office est de 64 bits.

si HKLM\Software\WOW6432Node n'existe pas, Alors Windows et Office sont 32 bits.

Source: Forums Technet

vous pouvez faire une recherche dans le Registre pour {90140000-0011-0000- 0000 -0000000FF1CE}. Si les nombres en gras commencent par 0 son x86, 1 est x64

Pour moi, c'était dans HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\14.0 \ Registration{90140000-0057-0000-0000-0000000FF1CE}

Source

ce code InnoSetup fonctionne pour moi sous Win 10x64 et Office 2016 x86 (en utilisant 'HKLM\SOFTWARE\Microsoft\Office\ClickToRun\Configuration' et la touche 'Platform')

[Code]
const
  RegOffice='SOFTWARE\Microsoft\Office\ClickToRun\Configuration';
  RegOfficeKey='Platform';

/// <summary>
/// Get current HKLM version
/// </summary>
function GetHKLM: Integer;
begin
  if IsWin64 then
    Result := HKLM64
  else
    Result := HKLM32;
end;

/// <summary>
/// Check is Microsoft Office is installed or not
/// </summary>
function IsOfficeInstalled (): Boolean;
var
  platform: string;
begin
  RegQueryStringValue(GetHKLM(), RegOffice, RegOfficeKey, platform);
  if platform = 'x86' then begin
   SuppressibleMsgBox('Microsoft Office found (x86 version)' , mbConfirmation, MB_YESNO or MB_DEFBUTTON1, IDYES);
    Result := True;
  end else if platform = 'x64' then begin
    SuppressibleMsgBox('Microsoft Office found (x64 version)', mbConfirmation, MB_YESNO or MB_DEFBUTTON1, IDYES);
    Result := True;
  end else begin
    SuppressibleMsgBox('Microsoft Office NOT found' + platform + '.', mbConfirmation, MB_YESNO or MB_DEFBUTTON1, IDYES);
    Result := False;
  end;
end;

Je n'ai pas de clé appelée bitness dans ces dossiers. J'ai une clé appelée "default" dans ces deux dossiers et la valeur est "unset" mon ordinateur est venu avec office 2010 starter (je suppose 64 bits). Je l'ai enlevé et essayé de faire une installation complète de bureau 32 bits. Je reçois le message suivant. le fichier est incompatible, vérifiez si vous avez besoin de la version x86 ou x64 du programme.

un conseil pour moi?

@clatonh: c'est le chemin du Registre sur mon PC: HKEY_LOCAL_MACHINE\SOFTWARE \ Microsoft\Office\14.0 \ Registration{90140000-002A-0000-1000-0000000FF1CE} et c'est certainement une installation 32 bits sur un OS 64 bits.

j'ai précédemment suivi aveuglément la réponse basée sur les docs MSDN. Aujourd'hui, il s'est avéré être moins que prévu. Sur une machine avec la maison de bureau et L'étudiant installé, qui ne comprend pas Outlook, HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Office.0\Outlook était présent, mais HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office.0\Outlook n'était pas. J'ai maintenant changé mon code pour chercher d'abord la version non-Wow6432Node "simple". Si c'est présent, il sera utilisé. Si ce n'est pas le cas, il continuera en regardant la version Wow6432Node. Ceci est vérifié dans un Inno Setup-based installateur - Je ne sais pas ce que APIs Inno Setup utilise. Si votre application n'accède pas au registre de la même manière, vous pourriez voir des résultats différents.

voici ce que j'ai pu utiliser dans un VBscript pour détecter Office 64bit Outlook:

Dim WshShell, blnOffice64, strOutlookPath
Set WshShell = WScript.CreateObject("WScript.Shell")
blnOffice64=False
strOutlookPath=WshShell.RegRead("HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\outlook.exe\Path")
If WshShell.ExpandEnvironmentStrings("%PROCESSOR_ARCHITECTURE%") = "AMD64" And _
    not instr(strOutlookPath, "x86") > 0 then 
  blnOffice64=True
  wscript.echo "Office 64"
End If

j'ai d'abord écrit ceci pour Outlook. Modifié un peu pour Word, mais il ne fonctionnera pas sur une installation autonome parce que cette clé ne montre pas le bitness, seul Outlook le fait.

aussi, je l'ai écrit pour ne supporter que les versions actuelles de Office, = > 2010

j'ai enlevé toute la configuration et le traitement post...

:checkarch
    IF NOT "%PROCESSOR_ARCHITECTURE%"=="x86" SET InstallArch=64bit
    IF "%PROCESSOR_ARCHITEW6432%"=="AMD64" SET InstallArch=64bit
    IF "%InstallArch%"=="64bit" SET Wow6432Node=\Wow6432Node
GOTO :beginscript

:beginscript
SET _cmdDetectedOfficeVersion=reg query "HKEY_CLASSES_ROOT\Word.Application\CurVer"
@FOR /F "tokens=* USEBACKQ" %%F IN (`!_cmdDetectedOfficeVersion! 2^>NUL `) DO (
SET _intDetectedOfficeVersion=%%F
)
set _intDetectedOfficeVersion=%_intDetectedOfficeVersion:~-2%


:switchCase
:: Call and mask out invalid call targets
    goto :case!_intDetectedOfficeVersion! 2>nul || (
:: Default case
    ECHO Not installed/Supported
    )
  goto :case-install

:case14
    Set _strOutlookVer= Word 2010 (!_intDetectedOfficeVersion!)
    CALL :GetBitness !_intDetectedOfficeVersion!
    GOTO :case-install  
:case15
    Set _strOutlookVer= Word 2013 (!_intDetectedOfficeVersion!)
    CALL :GetBitness !_intDetectedOfficeVersion!
    GOTO :case-install
:case16
    Set _strOutlookVer= Word 2016 (!_intDetectedOfficeVersion!)
    CALL :GetBitness !_intDetectedOfficeVersion!
    goto :case-install
:case-install
    CALL :output_text !_strOutlookVer! !_strBitness! is installed
GOTO :endscript


:GetBitness
FOR /F "tokens=3*" %%a in ('reg query "HKLM\Software%Wow6432Node%\Microsoft\Office\%1.0\Outlook" /v Bitness 2^>NUL') DO Set _strBitness=%%a
GOTO :EOF

j'ai gagné 7 64 bit + Excel 2010 32 bit. Le registre est HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\14.0\Registration{90140000-002A-0000-1000-0000000FF1C}

pour que cela puisse dire bitness de OS, pas bitness de bureau

j'ai trouvé un moyen sûr et fiable dans mon script InnoSetup-basé pour comprendre si une application particulière est 32-bit ou 64-bit (dans mon cas, je devais tester Excel), en utilisant une fonction D'API Win32. Cette fonction est appelée GetBinaryType() , elle vient de "kernel32" (malgré le nom qu'elle vient en saveur 32 et 64 bits) et regarde directement l'en-tête de l'exe.

cet article de Wikipedia déclare:

sur les versions 64 bits de Windows, il y a deux dossiers pour les fichiers application; le dossier "Program Files" contient des programmes 64 bits, et le dossier "Program Files (x86)" contient des programmes 32 bits.

Donc, si le programme est installé sous C:\Program Files c'est une version 64 bits. S'il est installé sous C:\Program Files (x86) , il s'agit d'une installation 32 bits.

une autre façon de détecter l'amertume du bureau est de trouver le typelib.

par exemple, pour détecter le bitness D'Outlook, écrivez A.Fichier JS comme suit:

function detectVersion()
    var outlooktlib = "TypeLib\{00062FFF-0000-0000-C000-000000000046}";
    var HKCR = 0x80000000;

    var loc = new ActiveXObject("WbemScripting.SWbemLocator");
    var svc = loc.ConnectServer(null,"root\default");
    var reg = svc.Get("StdRegProv");

    var method = reg.Methods_.Item("EnumKey");
    var inparam = method.InParameters.SpawnInstance_();
    inparam.hDefKey = HKCR;
    inparam.sSubKeyName = outlooktlib;
    var outparam = reg.ExecMethod_(method.Name,inparam);
    tlibver = outparam.sNames.toArray()[0];

    method = reg.Methods_.Item("GetStringValue");
    inparam = method.InParameters.SpawnInstance_();
    inparam.hDefKey = HKCR;
    inparam.sSubKeyName = outlooktlib + "\" + tlibver + "\0\win32";
    inparam.sValueName = "";
    outparam = reg.ExecMethod_(method.Name,inparam);
    if(outparam.sValue) return "32 bit";

    method = reg.Methods_.Item("GetStringValue");
    inparam = method.InParameters.SpawnInstance_();
    inparam.hDefKey = HKCR;
    inparam.sSubKeyName = outlooktlib + "\" + tlibver + "\0\win64";
    inparam.sValueName = "";
    outparam = reg.ExecMethod_(method.Name,inparam);
    if(outparam.sValue) return "64 bit";

    return "Not installed or unrecognizable";
}

vous pouvez trouver l'id typelib d'autres composants de bureau, et remplacer la première ligne de la fonction pour elle. Voici une brève liste d'IDs intéressants:

{4AFFC9A0-5F99-101B-AF4E-00AA003F0F07} - Access
{00020905-0000-0000-C000-000000000046} - Word
{00020813-0000-0000-C000-000000000046} - Excel
{91493440-5A91-11CF-8700-00AA0060263B} - Powerpoint
{0002123C-0000-0000-C000-000000000046} - Publisher
{0EA692EE-BB50-4E3C-AEF0-356D91732725} - OneNote 2010+
{F2A7EE29-8BF6-4A6D-83F1-098E366C709C} - OneNote 2007

tous les numéros ci-dessus libid ont été trouvés à travers L'outil Windows SDK OLE-COM Object Viewer , vous on pourrait en savoir plus en l'utilisant.

l'avantage de cette approche est qu'elle fonctionne pour toutes les versions de office, et fournit le contrôle sur chaque composant dans votre intérêt. De plus, ces clés se trouvent dans le HKEY_CLASSES_ROOT et sont profondément intégrées dans le système, de sorte qu'il est très peu probable qu'elles n'étaient pas accessibles même dans un environnement de bac à sable.

notez bien: la fonction detectVersion listée ci-dessus ne fonctionne pas . J'ai une version 64 bits d'Office, et une autre avec 32. Les deux versions utilisant cette fonction retournent "32 bit".

la vérification manuelle du registre aboutit à la même conclusion: les deux bit 64 et 32 (Office 2010 x64 et Office 2013 32 bit) report 32 bit.

personnellement, je pense que l'équipe de bureau devrait simplement écrire et maintenir un facile à obtenir clé de registre quelque part. Tous les add-in besoin de faire référence à cela, et actuellement "deviner" est une mauvaise approche pour les développeurs d'être forcé d'utiliser.

Vous n'avez pas besoin de l'écrire. Regardez cette page que je suis tombé sur:

https://social.msdn.microsoft.com/Forums/office/en-US/43499ae0-bcb5-4527-8edb-f5a955987b56/how-to-detect-whether-installed-ms-office-2010-is-32-or-64-bit?forum=worddev

pour résumer:

le quatrième champ du productcode indique le bitness du produit.

(BRMMmmmm-PPPP-LLLL - p 000-D000000FF1CE} p000

0 pour x86, 1 Pour x64 0-1 (cela vaut également pour MSOffice 2013)

recherchez dans le registre le chemin d'installation du composant office qui vous intéresse, p.ex. pour Excel 2010, recherchez le logiciel(Wow6432Node)\Microsoft\Office\14.0\Excel\InstallRoot. Il ne sera que dans le Registre à 32 bits ou dans le Registre à 64 bits, pas les deux.

Outlook Bitness clé de registre n'existe pas sur ma machine.

une façon de déterminer la Bitness Outlook est en examinant Outlook.exe, elle-même et de déterminer si elle est de 32bit ou 64bit.

en particulier, vous pouvez vérifier le [IMAGE_FILE_HEADER.Machine] [1] type et cela renvoie une valeur indiquant le type de processeur.

pour un excellent fond de cette discussion, à la lecture de L'en-tête PE d'un fichier Lire ce (lien périmé) , qui indique;

la structure IMAGE_NT_HEADERS est l'emplacement principal où les détails du fichier PE sont stockés. Son offset est donné par le champ E_LFANEW dans L'IMAGE_DOS_HEADER au début du fichier. Il existe en fait deux versions de la structure IMAGE_NT_HEADER, l'une pour les exécutables 32 bits et l'autre pour les versions 64 bits. Les différences sont si mineures que je les considérerai comme identiques aux fins de la présente discussion. La seule façon correcte, approuvée par Microsoft, de différencier les deux formats est via la valeur du champ Magic dans IMAGE_OPTIONAL_HEADER (décrit ci-dessous).

un IMAGE_NT_HEADER est composé de trois champs:

typedef struct _IMAGE_NT_HEADERS { DWORD Signature; IMAGE_FILE_HEADER FileHeader; IMAGE_OPTIONAL_HEADER32 OptionalHeader; } IMAGE_NT_HEADERS32, *PIMAGE_NT_HEADERS32;

et vous pouvez obtenir le code c ici .

le champ magique est au début de la structure IMAGE_OPTIONAL_HEADER, 2 octets à l'offset 24 dès le début des _IMAGE_NT_HEADERS. Il a des valeurs de 0x10B pour 32 bits et de 0x20B pour 64 bits.

Pas via la base de registre, mais via des outils en ligne de commande:

https://stackoverflow.com/a/6194710/2885897

C:\Users\me > assoc .msg

.msg=Outlook.Fichier.msg.15

C:\Users\me > ftype Outlook.Fichier.msg.15

Outlook.Fichier.msg.15="C:\Program fichiers ( x86 ) \Microsoft Office\Root\Office16\OUTLOOK.EXE" / f "%1 "

la manière la plus simple: placez l'icône ABOUT sur votre Application Office 2016. Exemple Excel

1) Ouvrez Excel -> Fichier -> Options -> Personnaliser Le Ruban

2) vous verrez 2 vitres. Choisir Des Commandes Et Personnaliser Le Ruban

3) À Partir De Choisir La Commande, Sélectionner Toutes Les Commandes

4) de la liste résultante sur (Excel)

5) de la personnaliser la douleur du ruban, surligner Élément (ex. Voir) où vous voulez mettre l'icône

6) Cliquez sur Nouveau groupe en bas de la page

7) Cliquez sur le bouton ajouter situé entre les deux volet. FAIT

maintenant, lorsque vous cliquez sur l'onglet View dans excel et cliquez sur about, vous verrez 32 bits ou 64 bits

j'ai trouvé le moyen de vérifier le bitness de bureau .

nous pouvons vérifier office 365 et 2016 bitness en utilisant cette clé de registre:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration

plate-forme X86 pour 32 bits.

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration

plate-forme x64 pour 64 bits.

s'il vous Plaît vérifier...

j'ai trouvé un moyen plus facile. En utilisant Powershell, nous pouvons hook Excel comme un objet COM.

$user = $env:UserName
$msoExcel = New-Object -ComObject Excel.Application  
$msoExcel | Select-Object -Property OperatingSystem | Out-File "\SERVER\Path\To\Dump\msoVersion-$user.txt"
exit

lorsque nous demandons le système D'exploitation de cette façon, nous obtenons des résultats étranges, regardez ici. Le PC3 est à moi.

j'espère que ça vous va. Désolé pour le manque de code; mes scripts sont généralement fonctionnel.

Modifier : N'oubliez pas d'ajouter le code pour fermer Excel après vous avez fini de récupérer les données.

Après avoir testé ce code hier, J'ai eu des tonnes D'Excel s'ouvrant et s'écrasant tout d'un coup..

cela vous permettra de garder les utilisateurs et les administrateurs heureux (:

[System.Runtime.Interopservices.Marshal]::ReleaseComObject($msoExcel)
Remove-Variable msoExcel

Si l'on veut savoir ce bit numéro de la version installée d'Office 2010, puis dans toutes les applications d'Office 2010, cliquez sur Fichier, puis sur Aide. Les informations sur le numéro de version seront listées, et à côté de cela, entre parenthèses, sera soit (32-bit) ou (64-bit).

Ouvrez Outlook 2013 > Fichier > Bureau > Sur Outlook > cliquez sur les grands "? À propos de Outlook "bouton > Lire la description popup