Detectar se o Office é 32 ou 64 bits através do registro

https://stackoverflow.com/questions/2203980

18-09-2019
|

Pergunta

Agora que o Office também vem em uma 64bit instalar, onde no registro que você descobrir se a versão do Office instalada é de 32 ou 64 bits?

Solução

Do artigo TechNet sobre rel="noreferrer"> href="http://technet.microsoft.com/en-us/library/ee681792(office.14).aspx" :

Se você instalou o Office 2010 incluindo o Microsoft Outlook 2010, Outlook define uma chave do Registro chamada Bitness do tipo REG_SZ no computador no qual está instalado. o Bitness chave de registro indica se a instalação Outlook 2010 é de 32 bits ou 64 bits. Isso pode ser os administradores que são úteis interessado em computadores de auditoria para determinar as versões instaladas do Office 2010 em sua organização.

caminho
Registro: HKEY_LOCAL_MACHINE \ Software \ Microsoft \ Office \ 14.0 \ Outlook

se você tiver instalado Office 2013, em seguida, usar esse caminho do registro: HKEY_LOCAL_MACHINE \ Software \ Microsoft \ Office \ 15.0 \ Outlook
tecla
Registro: Bitness

Valor: x86 ou x64

e em outros lugares no mesmo artigo:

A partir do Office 2010, Outlook é disponível como uma aplicação de 32 bits e uma aplicação de 64 bits. A versão (Bitness) do Outlook que você escolher depende da edição do Windows sistema operacional (de 32 bits ou 64 bits) e a edição do Office 2010 (32 ou 64 bits) que é instalado sobre o computador, se o Office já está instalado no computador.

Os fatores que determinam a viabilidade de instalar um de 32 bits ou de 64 bits versão do Outlook incluem o seguinte:

Você pode instalar 32 bits do Office 2010 e de 32 bits do Microsoft Outlook 2010 em um suportado edição do sistema operacional Windows de 32 bits ou de 64 bits. Você pode instalar a versão do Office 2010 e Outlook 2010 de 64 bits somente em um sistema operacional de 64 bits suportadas de 64 bits.

A instalação padrão do Office 2010 em uma edição do sistema operacional Windows de 64 bits é de 32 bits do Office 2010.

O número de bits de uma versão instalada do Outlook é sempre o mesmo que o número de bits do Office 2010, se o Office está instalado no mesmo computador. Ou seja, uma versão do Outlook 2010 de 32 bits não pode ser instalado no mesmo computador em que versões de outros aplicativos do Office 2010 de 64 bits já estão instalados, como 64-bit Microsoft Word 2010 ou de 64 bits do Microsoft Excel 2010. Da mesma forma , uma versão do Outlook 2010 de 64 bits não pode ser instalado no mesmo computador em que versões de outros aplicativos do Office de 32 bits já estão instalados.

Outras dicas

Eu testei a resposta de Otaku e parece que o valor do Outlook bitness está definido mesmo quando o Outlook não está instalado, mesmo que o artigo referenciado não indica claramente que este seria o caso.

Para adicionar a resposta de vtrz, aqui está uma função que eu escrevi para 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;

Lamento dizer, mas ambos de Otacku e @ métodos de clatonh não estão trabalhando para mim - nem têm Outlook Bitness nem {90140000-0011-0000- 1000 -0000000FF1CE} no registro (para 64- bit Office sem o Outlook instalado).

A única maneira que eu encontrei, porém, não através do registro, é verificar bitness para um dos executáveis ??do Office com o uso da função API do Windows GetBinaryType (desde o Windows 2000 Professional).

Por exemplo, você pode verificar o número de bits do Winword.exe, que caminho é armazenado sob
HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Windows \ CurrentVersion \ App Paths \ Winword.exe.

Aqui está o fragmento de código 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
}

Atenção:. Consultar o número de bits do aplicativo Outlook não confiável trabalho se for chamado em ambiente .NET

Aqui, usamos GetBinaryType () em uma DLL que pode ser chamado por qualquer aplicativo:

Se a aplicação inicial é de 64 bit C / C ++, GetBinaryType () retorna SCS_32BIT_BINARY.
Se o aplicativo host é 64 bit .NET (testamos "AnyCPU" em um sistema de 64 bits), GetBinaryType () retorna SCS_64BIT_BINARY.

Com exatamente o mesmo código DLL e exatamente o mesmo caminho binário Outlook. ( "C: / Arquivos de Programas (x86) / ...") no mesmo computador

O que significa que você pode precisar para testar o arquivo binário mesmo usando entrada "IMAGE_NT_HEADERS.FileHeader.Machine".

Deus, eu odeio os valores de retorno incorreto de algumas APIs do Windows (ver também GetVersion () mentira).

Eu encontrei o caminho para a verificação escritório bitness.

Podemos verificar o Office 365 e 2016 bitness usando esta chave de registo:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration

Plataforma x86 de 32 bits.

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration

Plataforma x64 de 64 bits.

Por favor, verifique ...

Eu encontrei esta abordagem:

Se HKLM \ Software \ WOW6432Node existe então o Windows é de 64 bits.

Se HKLM \ Software \ WOW6432Node \ Microsoft \ Office existe, então Office é de 32 bits.

Se HKLM \ Software \ WOW6432Node \ Microsoft \ Office não existe, mas HKLM \ Software \ Microsoft \ Office existe, então Office é de 64 bits.

Se HKLM \ Software \ WOW6432Node não existe, então o Windows e Office são de 32 bits.

Fonte: Technet Fóruns

Aqui está o que eu era capaz de usar em um VBScript para detectar o Office 64 bits 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

Você pode pesquisar o registro para {90140000-0011-0000- 0000 -0000000FF1CE}. Se os números em negrito começar com 0 a 86, 1 é x64

Para mim, foi em HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Office \ 14.0 \ Registration {90140000-0057-0000-0000-0000000FF1CE}

Fonte

Este código InnoSetup está funcionando para mim sob Win 10x64 e Office 2016 x86 (usando '\ ClickToRun \ Configuration HKLM \ SOFTWARE \ Microsoft \ Office' e chave 'Plataforma')

[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;

Eu não tenho uma chave chamada bitness em qualquer uma destas pastas. Eu tenho uma chave chamada "default" em ambas as pastas eo valor é "desactivado" Meu computador veio com o Office 2010 Starter (presumo 64 bit). Tirei-o e tentou fazer uma instalação completa do Office de 32 bits. Recebo a seguinte mensagem. o arquivo é incompatível, verificar para ver se você precisa de x86 ou x64 versão do programa.

algum conselho para mim?

@clatonh: este é o caminho do registro no meu PC: HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Office \ 14.0 \ Registration {90140000-002A-0000-1000-0000000FF1CE} e é definitivamente um 32-bit-instalação em um 64-bit OS.

Eu já anteriormente seguido cegamente a resposta com base nos docs MSDN. Hoje, esta acabou por ser menos do que o necessário. Em uma máquina com o Office Home and Student instalado, que não inclui Outlook, HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Office\14.0\Outlook estava presente, mas HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\14.0\Outlook não era. Eu já mudei meu código para olhar primeiro para a versão "simples" não-Wow6432Node. Se isso é presente, ele vai ser usado. Se não, ele vai continuar olhando para a versão Wow6432Node. Isso está sendo verificado em um instalador baseado em Inno Setup - Eu não sei quais APIs Inno Setup usos. Se seu aplicativo não acessar o registro da mesma forma, você pode ver resultados diferentes.

Eu escrevi isso para Outlook em primeiro lugar. Modifiquei um pouco para o Word, mas não vai trabalhar em um autônomo instalar porque essa chave não mostra o número de bits, apenas o Outlook faz.

Além disso, eu escrevi para suportar apenas as versões atuais do Office, => 2010

Tirei toda a configuração e pós processamento ...

: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

Em meus testes muitas das abordagens descritas aqui falhar, acho que porque eles dependem de entradas no registro do Windows que vir a ser não confiável presente, dependendo da versão do Office, como ele foi instalado etc. Assim, uma abordagem diferente é não usar o registro em todos (Ok, tão estritamente que faz com que não uma resposta para a questão colocada), mas em vez escrever um script que:

instancia Excel
Adiciona uma pasta de trabalho para essa instância Excel
adiciona um VBA módulo para essa pasta de trabalho
injeta uma pequena função VBA que retorna o número de bits do Office
As chamadas que a função
limpa

Aqui é que a abordagem implementada no 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. Esta abordagem é executado mais lentamente do que outros aqui (cerca de 2 segundos no meu PC), mas ele pode vir a ser mais confiável em diferentes instalações e versões do Office.

Depois de alguns meses, eu percebi que pode haver uma abordagem mais simples, embora ainda um que instancia uma instância Excel. O VBScript é:

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

Esta se baseia no fato de que Application.OperatingSystem, quando chamado a partir de 32 bits do Excel no Windows de 64 bits retorna Windows (32-bit) NT 10.00 ou pelo menos ele faz no meu PC. Mas isso não é mencionado no docs .

Eu tenho win 7 64 bits + Excel 2010 de 32 bits. O registro é HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Office \ 14.0 \ Registration {90140000-002A-0000-1000-0000000FF1CE}

Portanto, este pode dizer número de bits do sistema operacional, não número de bits do Office

Eu encontrei uma maneira segura e confiável no meu script baseado em InnoSetup para entender se um aplicativo específico é de 32 bits ou de 64 bits (no meu caso eu precisava para testar Excel), usando uma função API Win32. Esta função é chamada GetBinaryType(), vem de `kernel32' (apesar do nome vem no sabor 32 e 64 bits) e olha diretamente para o cabeçalho do exe.

estados este artigo Wikipedia :

Em versões de 64 bits do Windows, há duas pastas para arquivos de aplicativos; a pasta "Program Files" contém programas de 64 bits, ea pasta "Program Files (x86)" contém programas de 32 bits.

Então, se o programa está instalado sob C:\Program Files é uma versão de 64-bit. Se for instalado sob C:\Program Files (x86) é uma instalação de 32 bits.

Outra forma de detectar o número de bits do Office é para descobrir o typelib.

Por exemplo, para detectar bitness do Outlook, escrever uma .js como a seguir:

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";
}

Você pode descobrir id typelib do outro componente do Office, e substituir a primeira linha da função para ele. Aqui está uma lista breve de IDs interessantes:

{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

Todos os id lib acima foram encontrados através do OLE-COM Object Viewer ferramenta Windows SDK, você pode descobrir mais lib id usando-o.

A vantagem dessa abordagem é que ele funciona para todas as versões do Office, e fornece controle sobre cada componente em seu interesse. Além disso, as chaves estão no HKEY_CLASSES_ROOT e profundamente integrado ao sistema, por isso é altamente improvável que eles não eram acessíveis mesmo em um ambiente sandbox.

Note bem: A função detectVersion listados acima não trabalho . Eu tenho uma versão de 64 bits do Office, e uma separada com 32. Ambas as versões usando esta função de retorno "de 32 bits".

Verificar os leads registro manualmente para a mesma conclusão:. Tanto de 64 bits e 32 (Office 2010 x64 e Office 2013 32 bits) relatório de 32 bits

Pessoalmente acho que a equipe do Office deve simplesmente escrever e manter um fácil de obter em algum lugar chave de registro. Todos os add-in de precisar fazer referência a isso, e, atualmente, "adivinhar" é uma abordagem pobre para desenvolvedores será forçado a usar.

Você não precisa escrevê-lo. Olhada nesta página que eu tropecei através de:

https://social.msdn.microsoft.com/Forums/office/en-US/43499ae0-bcb5-4527- 8edb-f5a955987b56 / how-to-detectar-se-instalados-ms-office-2010-é-32-ou-64-bit? fórum = worddev

Para resumir:

O quarto campo no ProductCode indica o número de bits do produto.

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

0 para x86, 1 para x64 0-1 (Isto também é válido para MSOffice 2013)

Pesquisar o registro para o caminho de instalação do componente de escritório que você está interessado em, por exemplo, para Excel 2010 olhar no SOFTWARE (Wow6432Node) \ Microsoft \ Office \ 14.0 \ Excel \ InstallRoot. Será somente quer no registo de 32 bits ou o registo de 64 bits não ambos.

Outlook Bitness chave de registo não existe na minha máquina.

Uma maneira de determinar Outlook Bitness é examinar Outlook.exe, a si mesmo e determinar se é 32 ou 64 bits.

Especificamente, você pode verificar o [IMAGE_FILE_HEADER.Machine] [1] tipo e isso irá retornar um valor que indica o tipo de processador.

Para uma excelente fundo desta discussão, ao ler o cabeçalho PE de um arquivo ler este (link desatualizado) , que afirma;

A estrutura IMAGE_NT_HEADERS é o principal local onde especificidades do arquivo de PE são armazenados. Seu deslocamento é dada pelo campo e_lfanew na IMAGE_DOS_HEADER no início do arquivo. Na verdade, existem duas versões da estrutura IMAGE_NT_HEADER, uma para executáveis ??de 32 bits e o outro para as versões de 64 bits. As diferenças são tão pequenas que eu vou considerá-los a ser o mesmo para os fins desta discussão. A única maneira correta, Microsoft-aprovado de diferenciar entre os dois formatos é através do valor do campo Magia no IMAGE_OPTIONAL_HEADER (descrita em breve).

Um IMAGE_NT_HEADER é composto por três campos:

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

e você pode obter o código c # aqui .

O campo mágica é no início da estrutura IMAGE_OPTIONAL_HEADER, 2 bytes no deslocamento 24 a partir do início dos _IMAGE_NT_HEADERS. Tem valores de 0x10B para 32 bits e 0x20B para 64 bits.

Não através do registro, mas através de ferramentas de linha de comando:

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 ( 86 ) \ Microsoft Office \ Root \ Office16 \ OUTLOOK.EXE" / f "% 1"

Melhor maneira fácil: colocar o ícone SOBRE em seu aplicativo do Office 2016. Exemplo Excel

1) Abra o Excel -> Arquivo -> Opções -> Personalizar Faixa

2) Você verá 2 painéis. Escolha comandos e personalizar a fita

3) de Escolha de comando, selecione Todos os comandos

4) na lista resultante Destaque Sobre (Excel)

5) da dor personalizar a faixa, realçar os itens (ex. View) onde pretende colocar o ícone Sobre

6) Clique em Novo grupo na parte inferior

7) Clique no botão Adicionar localizado entre dois painel. FEITO

Agora, quando você clique na guia Exibir no Excel e clique sobre você verá 32 bits ou 64 bits

Eu encontrei uma maneira muito mais fácil. Usando PowerShell, podemos ligar Excel como um objeto 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

Ao solicitar o OperatingSystem Desta forma, obtemos resultados estranhos, dê uma olhada aqui. PC3 é meu.

Espero que isso funciona para vocês. Desculpem a falta de código; meus scripts são principalmente funcional.

Editar : Não se esqueça de adicionar o código para fechar o Excel depois que você fez recuperar os dados.
Depois de testar este código ontem eu tinha toneladas de abertura Excel e deixar de funcionar de repente ..
Isto irá certificar-se de que você vai manter os usuários e administradores feliz (:

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

EDIT:. Solution sem RegistryKeys tocantes - im Op Desculpe

Eu descobri que há uma solução em C # - o original pode ser encontrada aqui: https: / /blogs.msdn.microsoft.com/webdav_101/2016/07/26/sample-detecting-installed-outlook-and-its-bitness/

Eu modifiquei um pouco para as minhas necessidades.

apenas passar o outlookPath correto 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;



    }

Se alguém quiser saber apenas o que mordeu número uma versão instalada do Office 2010 é, em seguida, em qualquer aplicativo do Office 2010, basta clicar em Arquivo e depois em Ajuda. Informações sobre o número da versão será listada, e ao lado que, entre parênteses, será ou (32-bit) ou (64-bit).

Abra o Outlook 2013> Arquivo> conta do Office> Sobre Outlook> clique em grande botão "? Sobre Outlook"> Descrição leitura pop-up

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow