Détecter si le Bureau est 32 bits ou 64 bits via le registre

StackOverflow https://stackoverflow.com/questions/2203980

Question

Maintenant que l'Office est également livré dans un 64 bits, installer, où dans le registre savez-vous si la version d'Office installée est 32bit ou 64bit?

Était-ce utile?

La solution

De l'article TechNet sur Les éditions 64 bits d'Office 2010:

Si vous avez installé Office 2010 y compris Microsoft Outlook 2010, Outlook définit une clé de registre nommée Nombre de bits de type REG_SZ sur l'ordinateur sur lequel il est installé.L' Nombre de bits clé de registre indique si les Perspectives 2010 de l'installation est 32-bits ou 64-bits.Cela peut être utile pour les administrateurs qui sont intéressé dans l'audit des ordinateurs déterminer les versions installées Office 2010 dans leur organisation.

  • Chemin d'accès du registre: HKEY_LOCAL_MACHINE\Software\Microsoft\Office\14.0\Outlook
  • si vous avez installé Office 2013 puis utiliser cette Chemin d'accès du registre: HKEY_LOCAL_MACHINE\Software\Microsoft\Office\15.0\Outlook
  • Clé de registre: Nombre de bits
  • Valeur:x86 ou x64

et d'ailleurs dans le même article:

Départ avec Office 2010, Outlook disponible comme une application 32 bits et une application 64 bits.La version (nombre de bits) de Outlook que vous choisissez dépend de l'édition de Windows système d'exploitation (32 bits ou 64 bits) et l'édition d'Office 2010 (32 ou 64-bit) est installé sur l' ordinateur, si Office est déjà installé sur cet ordinateur.

Les facteurs qui déterminent la faisabilité de l'installation d'une version 32 bits ou 64 bits la version de Outlook inclure la suivantes:

  • Vous pouvez installer la version 32 bits d'Office 2010 et 32 bits de Microsoft Outlook 2010 sur la prise en charge 32 bits ou 64 bits du système d'exploitation Windows.Vous pouvez installer la version 64 bits d'Office 2010 et 64 bits Outlook 2010 sur un système d'exploitation 64 bits.
  • L'installation par défaut de microsoft Office 2010 sur une version 64 bits du système d'exploitation Windows est 32 bits d'Office 2010.
  • Le nombre de bits de la version installée de Outlook est toujours le même que le nombre de bits d'Office 2010, si microsoft Office est installé sur le même ordinateur.C'est une version 32 bits de microsoft Outlook 2010 ne peut pas être installé sur le même ordinateur sur lequel les versions 64 bits de d'autres applications Office 2010 sont déjà installés, tels que les 64 bits de Microsoft Word 2010 ou 64 bits de Microsoft Excel 2010.De même, une version 64 bits de microsoft Outlook 2010 ne peut pas être installé sur le même ordinateur sur lequel les versions 32 bits des autres applications Office sont déjà installés.

Autres conseils

Je l'ai testé la réponse de Otaku et il semble que la valeur bitness Outlook est défini, même si Outlook 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 écrit 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;

Regret à dire, mais deux de Otacku et les méthodes de @ clatonh ne fonctionnent pas pour moi - ni qu'Outlook Bitness ni {90140000-0011-0000- 1000 } -0000000FF1CE dans le registre (pour 64- office bit sans Outlook installé).

La seule façon que je l'ai trouvé, cependant, pas par le registre, est de vérifier bitness pour l'un des executables de bureau avec l'utilisation de la fonction API Windows GetBinaryType (depuis Windows 2000 professionnel).

Par exemple, vous pouvez vérifier le nombre de bits de Winword.exe, le chemin qui 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:. Interroger le nombre de bits de l'application Outlook ne fonctionne pas de manière fiable si elle est appelée dans un environnement .NET

Ici, nous utilisons GetBinaryType () dans une DLL qui peut être appelée par toute application:

  • Si l'application hôte est de 64 bit C / C ++, GetBinaryType () retourne SCS_32BIT_BINARY.
  • Si l'application hôte est de 64 bits .NET (nous avons testé "AnyCPU" sur un système 64 bits), 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

Ce qui signifie que vous pourriez avoir besoin de tester le fichier binaire en utilisant vous entrée « IMAGE_NT_HEADERS.FileHeader.Machine ».

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

J'ai trouvé la façon de vérifier bitness de bureau.

Nous pouvons vérifier le bureau 365 et 2016 bitness utilisant cette clé de Registre: 

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration

Platform x86 32 bits. 

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration

64 bits de la plate-forme 64 bits.

S'il vous plaît vérifier ...

Je trouve cette approche:

Si HKLM \ Software \ WOW6432Node existe alors de Windows 64 bits.

Si HKLM \ Software \ WOW6432Node \ Microsoft \ Bureau existe, puis Office est 32 bits.

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

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

Source: Technet Forums

Voici ce que j'ai pu utiliser dans un VBscript pour détecter Bureau 64bit Perspectives: 

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

Vous pouvez rechercher le Registre pour {90140000-0011-0000- 0000 -0000000FF1CE}. Si les chiffres en gras commencent par 0 son x86, 1 est x64

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

Source

Ce code InnoSetup travaille pour moi sous Win 10x64 et Office 2016 x86 (en utilisant 'HKLM \ SOFTWARE \ Microsoft \ Office \ ClickToRun \ Configuration' et touche 'Plate-forme') 

[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 une clé appelée bitness dans l'un de ces dossiers. J'ai une clé appelée « par défaut » dans ces deux dossiers et la valeur est « hors service » Mon ordinateur est venu avec entrée Office 2010 (je suppose que 64 bits). Je l'ai enlevé et essayé de faire une installation complète de 32 bits bureau. Je continue à recevoir le message suivant. le fichier est incompatible, vérifiez si vous avez besoin x86 ou version 64 bits du programme.

des conseils pour moi?

@clatonh: ceci est le chemin du registre sur mon PC: HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Office \ 14.0 \ Registration {} 90140000-002A-0000-1000-0000000FF1CE et il est certainement un 32 bits installation sur un système d'exploitation 64 bits.

Je l'ai déjà aveuglément suivi la réponse sur la base des documents MSDN. Aujourd'hui, cela se révèle être moins nécessaire. Sur une machine avec Office Home and Student installé, qui ne comprend pas Outlook, HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Office\14.0\Outlook était présent, mais n'a pas été HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\14.0\Outlook. J'ai changé mon code pour regarder d'abord pour la « plaine » version non Wow6432Node. Si c'est présent, il sera utilisé. Dans le cas contraire, elle continuera en regardant la version Wow6432Node. Ceci est en cours de vérification dans un programme d'installation par installation-Inno - Je ne sais pas les API utilisations Inno Setup. Si votre application n'accède pas au registre de la même manière, vous pouvez voir des résultats différents.

J'ai écrit ce pour Outlook dans un premier temps. Modifié un peu pour Word, mais il ne fonctionnera pas sur un autonome parce que la clé install ne montre pas le nombre de bits, que Outlook ne.

En outre, je l'ai écrit pour soutenir uniquement les versions actuelles de Microsoft Office, => 2010

Je retirai toute la configuration et post-traitement ... 

: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

Dans mes tests plusieurs des approches décrites ici échoue, je pense parce qu'ils comptent sur les entrées dans le registre Windows qui se révèlent ne pas être fiable présente, selon la version de bureau, comment il a été installé, etc. Ainsi, une approche différente est de ne pas utiliser le registre du tout (Ok, donc strictement qui le rend pas une réponse à la question posée), mais écrire un script qui:

  1. Instancie Excel
  2. Ajoute un classeur à cette instance Excel
  3. Ajoute un module VBA à ce classeur
  4. une petite fonction Injecte VBA qui renvoie le nombre de bits d'Office
  5. Appels cette fonction
  6. Nettoie

Voici cette approche mise en œuvre dans VBScript: 

Function OfficeBitness()

    Dim VBACode, Excel, Wb, Module, Result

    VBACode = "Function Is64bit() As Boolean" & vbCrLf & _
              "#If Win64 Then" & vbCrLf & _
              "    Is64bit = True" & vbCrLf & _
              "#End If" & vbCrLf & _
              "End Function"

    On Error Resume Next
    Set Excel = CreateObject("Excel.Application")
    Excel.Visible = False
    Set Wb = Excel.Workbooks.Add
    Set Module = Wb.VBProject.VBComponents.Add(1)
    Module.CodeModule.AddFromString VBACode
    Result = Excel.Run("Is64bit")
    Set Module = Nothing
    Wb.Saved = True
    Wb.Close False
    Excel.Quit
    Set Excel = Nothing
    On Error GoTo 0
    If IsEmpty(Result) Then
        OfficeBitness = 0 'Alternatively raise an error here?
    ElseIf Result = True Then
        OfficeBitness = 64
    Else
        OfficeBitness = 32
    End If

End Function

PS. Cette approche va plus lentement que d'autres ici (environ 2 secondes sur mon PC), mais il pourrait se révéler plus fiable dans les différentes installations et versions Office.

Après quelques mois, j'y ai réalisé peut être une approche plus simple, mais encore celui qui instancie une instance Excel. Le VBScript est: 

Function OfficeBitness()
    Dim Excel
    Set Excel = CreateObject("Excel.Application")
    Excel.Visible = False
    If InStr(Excel.OperatingSystem,"64") > 0 Then
        OfficeBitness = 64
    Else
        OfficeBitness = 32
    End if
    Excel.Quit
    Set Excel = Nothing
End Function

Cela repose sur le fait que Application.OperatingSystem, lorsqu'il est appelé à partir de 32 bits Excel sur Windows 64 bits retourne Windows (32-bit) NT 10.00 ou tout au moins il le fait sur mon PC. Mais ce n'est pas mentionné dans le docs .

Je win 7 64 bits + Excel 2010 32 bits. Le registre est HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Office \ 14.0 \ Registration {90140000-002A-0000-1000-0000000FF1CE}

Donc cela peut dire bitness d'OS, et non bitness de bureau

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

Cet article de Wikipedia états:

  

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

Donc, si le programme est installé sous C:\Program Files est une version 64 bits. Si elle est installée sous C:\Program Files (x86) est une installation 32 bits.

Une autre façon de détecter le nombre de bits d'Office est de trouver le typelib.

Par exemple, pour détecter le nombre de bits d'Outlook, écrire un 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 d'autres id typelib de composant Office et remplacer la première ligne de la fonction pour elle. Voici une brève liste des ID 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 ci-dessus id lib ont été détectés par l'outil de Windows SDK OLE-COM Object Viewer, vous pouvez savoir id plus lib de en l'utilisant.

L'avantage de cette approche est que cela fonctionne pour toutes les versions de bureau et assure le contrôle sur chaque composant dans l'intérêt que vous. De plus, ces clés sont dans le HKEY_CLASSES_ROOT et profondément intégrés dans le système, il est donc très peu probable qu'ils ne sont pas accessibles, même dans un environnement de bac à sable.

NOTEZ BIEN:Le detectVersion fonctions listées ci-dessus ne fonctionne pas.J'ai une version 64 bits d'Office, et une autre avec 32.Les deux versions à l'aide de cette fonction retourne "32 bits".

De vérifier manuellement le registre conduit à la même conclusion:64 et 32 bits (Office 2010 x64 et Office 2013 32 bits) rapport de 32 bits.

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

Vous n'avez pas besoin de script, il. Regardez cette page que je suis tombé sur:

https://social.msdn.microsoft.com/Forums/office/en-US/43499ae0-bcb5-4527- 8edb-f5a955987b56 / how-to-détecter-si-installed-ms-office-2010-est-32 ou 64 bits? forum = worddev

Pour résumer:

Le quatrième champ dans le productcode indique le nombre de bits du produit.

{BRMMmmmm-PPPP-LLLL- p 000 D000000FF1CE} P000

0 pour x86, 1 pour x64 0-1 (Ceci est également vrai pour MSOffice 2013)

Rechercher dans le Registre pour le chemin du composant de bureau d'installation vous intéresse, par exemple pour un look Excel 2010 dans le logiciel (Wow6432Node) \ Microsoft \ Office \ 14.0 \ Excel \ InstallRoot. Il ne sera dans le Registre 32 bits ou le registre 64 bits pas les deux.

Perspectives clé de Registre Bitness n'existe pas sur ma machine.

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

Plus précisément, vous pouvez vérifier la [IMAGE_FILE_HEADER.Machine] [1] type et cela renvoie une valeur indiquant le type de processeur.

Pour une excellente base de cette discussion, à la lecture du PE en-tête d'un fichier lu ce (lien périmé) , qui stipule;

La structure de IMAGE_NT_HEADERS est l'emplacement principal où des détails du fichier de PE sont stockés. Son décalage est donnée par le champ _lfanew dans le IMAGE_DOS_HEADER au début du fichier. Il y a en fait deux versions de la structure IMAGE_NT_HEADER, une pour executables 32 bits et l'autre pour les versions 64 bits. Les différences sont si peu que je les considère être les mêmes pour les fins de cette discussion. La seule correcte, façon Microsoft approuvé la différence entre les deux formats est par la valeur du champ magique dans le IMAGE_OPTIONAL_HEADER (décrit sous peu).

Un IMAGE_NT_HEADER est constitué 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 # .

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

Non via le registre, mais au moyen d'outils en ligne de commande:

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

C: \ Users \ me> assoc .msg

msg = Outlook.File.msg.15

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

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

La meilleure façon simple: Mettez l'icône A propos de votre bureau 2016 application. Exemple Excel

1) Ouvrez Excel -> Fichier -> Options -> Personnaliser le ruban

2) Vous verrez 2 volets. Choisir les commandes et personnaliser le ruban

3) De Choisissez commande, sélectionnez Toutes les commandes

4) A partir de la liste de résultats Highlight (Excel)

5) De la personnalisation La douleur du ruban, mettre en évidence tout article (ex. Voir) où vous voulez mettre l'icône A propos

6) Cliquez sur Nouveau groupe au bas

7) Cliquez sur le bouton Ajouter situé entre les deux volets. FAIT

Maintenant, lorsque vous cliquez sur l'onglet Affichage dans Excel et cliquez sur vous verrez 32 bits ou 64 bits

Je l'ai trouvé un moyen beaucoup plus facile. En utilisant Powershell, nous pouvons brancher 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 vous demandez la OperatingSystem de cette façon, nous obtenons des résultats étranges, ont un coup d'oeil ici. PC3 est à moi.

J'espère que cela fonctionne pour vous les gars. Désolé pour le manque de code; mes scripts sont surtout fonctionnels.

Modifier : Ne pas oublier d'ajouter le code pour fermer Excel après que vous avez terminé la récupération des données.
Après avoir testé hier code que j'avais des tonnes de toutes ouvrir et écraser Excel un coup ..
Cela fera en sorte que vous garderez les utilisateurs et les administrateurs heureux (: 

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

EDIT:. Solution sans toucher RegistryKeys - im Désolé Op

Je trouve qu'il ya une solution en C # - se trouve l'original ici: https: / /blogs.msdn.microsoft.com/webdav_101/2016/07/26/sample-detecting-installed-outlook-and-its-bitness/

Je l'ai modifié un peu pour mes besoins.

il suffit de passer le outlookPath correct GetOutlookBitness () 

  public enum BinaryType : uint

    {
        SCS_32BIT_BINARY = 0, // A 32-bit Windows-based application
        SCS_64BIT_BINARY = 6, // A 64-bit Windows-based application.
        SCS_DOS_BINARY = 1, // An MS-DOS – based application
        SCS_OS216_BINARY = 5, // A 16-bit OS/2-based application
        SCS_PIF_BINARY = 3, // A PIF file that executes an MS-DOS – based application
        SCS_POSIX_BINARY = 4, // A POSIX – based application
        SCS_WOW_BINARY = 2 // A 16-bit Windows-based application
    }



    [DllImport("kernel32.dll")]
    static extern bool GetBinaryType(string lpApplicationName, out BinaryType lpBinaryType);




    public int GetOutlookBitness(string FilePath)
    {
        int bitness = 0;

        if (File.Exists(FilePath))
        {
            BinaryType type;
            GetBinaryType(FilePath, out type);


            switch (type)
            {
                case BinaryType.SCS_32BIT_BINARY:
                    bitness = 32;
                    break;
                case BinaryType.SCS_64BIT_BINARY:
                    bitness = 64;
                    break;
            }
        }

        return bitness;



    }

Si l'on veut savoir que ce numéro de bit une version installée d'Office 2010 est donc dans une application d'Office 2010, cliquez sur Fichier, puis sur Aide. Informations sur le numéro de version sera affiché, et à côté de cela, entre parenthèses, sera soit (32 bits) ou (64 bits).

Ouvrez Outlook 2013> Fichier> Compte de bureau> À propos d'Outlook> cliquez sur grand bouton "? À propos d'Outlook"> lire la description contextuelle

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top