Detectar si Office es de 32 o 64 bits a través del registro

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

Pregunta

Ahora que Office también viene con una instalación de 64 bits, ¿en qué parte del registro puede saber si la versión de Office instalada es de 32 bits o de 64 bits?

¿Fue útil?

Solución

Del artículo de TechNet sobre Ediciones de 64 bits de Office 2010:

Si ha instalado Office 2010, incluida Microsoft Outlook 2010, Outlook establece una clave de registro nombrada Bitness de tipo REG_SZ en el ordenador en el que está instalado.El Bitness La clave de registro indica si la instalación de Outlook 2010 es de 32 bits o 64 bits.Esto puede ser útil para los administradores interesados ​​en auditar computadoras para determinar las versiones instaladas de Office 2010 en su organización.

  • Ruta de registro: HKEY_LOCAL_MACHINE\Software\Microsoft\Office\14.0\Outlook
  • Si ha instalado Office 2013, use esta ruta de registro: HKEY_LOCAL_MACHINE\Software\Microsoft\Office\15.0\Outlook
  • Clave de registro: Bitness
  • Valor:ya sea x86 o x64

y en otra parte del mismo artículo:

A partir de Office 2010, Outlook está disponible como una aplicación de 32 bits y una aplicación de 64 bits.La versión (bitness) de Outlook que elige depende de la edición del sistema operativo Windows (32 bits o 64 bits) y la edición de Office 2010 (32 o 64 bits) que está instalada en la computadora, si La oficina ya está instalada en esa computadora.

Los factores que determinan la viabilidad de instalar una versión de 32 bits o una versión de 64 bits incluyen lo siguiente:

  • Puede instalar Office 2010 de 32 bits y Microsoft Outlook 2010 de 32 bits en una edición compatible de 32 o 64 bits del sistema operativo Windows.Puede instalar la versión de 64 bits de Office 2010 y Outlook 2010 de 64 bits solo en un sistema operativo de 64 bits compatible.
  • La instalación predeterminada de Office 2010 en una edición de 64 bits del sistema operativo Windows es Office 2010 de 32 bits.
  • El bit de una versión instalada de Outlook es siempre el mismo que el de Office 2010, si Office está instalado en la misma computadora.Es decir, no se puede instalar una versión de 32 bits de Outlook 2010 en la misma computadora en la que ya están instaladas versiones de 64 bits de otras aplicaciones de Office 2010, como Microsoft Word 2010 de 64 bits o Microsoft Excel 2010 de 64 bits.De manera similar, no se puede instalar una versión de 64 bits de Outlook 2010 en la misma computadora en la que ya están instaladas versiones de 32 bits de otras aplicaciones de Office.

Otros consejos

He probado la respuesta de Otaku y parece que el valor de valor de bits de Outlook se establece incluso cuando Outlook no está instalado, a pesar de que el artículo de referencia no indica claramente que este sería el caso.

Para añadir a la respuesta de vtrz, he aquí una función que escribí 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 decirlo, pero ambos métodos de @ clatonh de Otacku y no están trabajando para mí - ni que Outlook bitness ni {90140000-0011-0000- 1000 -0000000FF1CE} en el registro (por 64- Oficina bits sin perspectiva instalado).

La única manera que he encontrado, sin embargo, no a través del registro, es comprobar valor de bits de uno de los ejecutables de Office con el uso de la función API de Windows GetBinaryType (desde Windows 2000 Professional).

Por ejemplo, se puede comprobar el valor de bits de Winword.exe, qué camino se almacena bajo
HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Windows \ CurrentVersion \ App Paths \ Winword.exe.

Este es el 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
}

Atención. Consultando el valor de bits de la aplicación de Outlook no funciona correctamente si se llama en el entorno .NET

A continuación, utilizamos GetBinaryType () en un archivo DLL que se puede llamar por cualquier aplicación:

  • Si la aplicación host es de 64 bit C / C ++, GetBinaryType () devuelve SCS_32BIT_BINARY.
  • Si la aplicación host es de 64 bits .NET (probamos "Cualquier CPU" en un sistema de 64 bits), GetBinaryType () devuelve SCS_64BIT_BINARY.

Con exactamente el mismo código DLL y exactamente la misma ruta binaria de Outlook. ( "C: / Archivos de programa (x86) / ...") en el mismo equipo

Lo que significa que puede que tenga que probar el archivo binario de sí mismo utilizando la entrada "IMAGE_NT_HEADERS.FileHeader.Machine".

Dios, odio los valores de retorno incorrectas de algunas API de Windows (véase también GetVersion () mentira).

He encontrado el camino para la comprobación de valor de bits de oficina.

Podemos comprobar la oficina 365 y 2016 bitness utilizando esta clave de registro: 

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration

x86 Plataforma de 32 bits. 

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration

x64 Plataforma de 64 bits.

Por favor, compruebe ...

He encontrado este enfoque:

Si HKLM \ Software \ WOW6432Node existe, entonces Windows es de 64 bits.

Si HKLM \ Software \ WOW6432Node \ Microsoft \ Office existe, entonces la oficina es de 32 bits.

Si no existe HKLM \ Software \ WOW6432Node \ Microsoft \ Office, pero HKLM \ Software \ Microsoft \ Office no existe, entonces la oficina es de 64 bits.

Si no existe HKLM \ Software \ WOW6432Node, a continuación, Windows y Office son de 32 bits.

Fuente: Technet Los foros de

Esto es lo que era capaz de utilizar en un VBScript para detectar Office Outlook de 64 bits: 

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

Puede buscar el registro para {90140000-0011-0000- 0000 -0000000FF1CE}. Si los números en negrita empiezan con 0 su x86, x64 1 es

Para mí fue en HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Office \ 14.0 \ Registro {90140000-0057-0000-0000-0000000FF1CE}

Fuente

Este código InnoSetup está trabajando para mí en Win 10x64 y Office 2016 x86 (usando 'HKLM \ SOFTWARE \ Microsoft \ Office \ ClickToRun \ Configuración' y 'Plataforma' llave) 

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

No tengo una clave llamada valor de bits en cualquiera de estas carpetas. Tengo una clave llamada "default" en ambas carpetas y el valor es "desactivada" Mi equipo viene con Office 2010 Starter (supongo 64 bits). Lo quité y trató de hacer una instalación completa de Office de 32 bits. Sigo recibiendo el siguiente mensaje. el archivo es incompatible, comprobar para ver si necesita x86 o x64 versión del programa.

algún consejo para mí?

@clatonh: este es el camino del registro en mi PC: HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Office \ 14.0 \ Registro {90140000-002A-0000-1000-0000000FF1CE} y es sin duda una de 32 bits de la instalación en un sistema operativo de 64 bits.

He seguido ciegamente previamente la respuesta sobre la base de la documentación de MSDN. Hoy en día, esto resultó ser menor que la requerida. En un equipo con Office Hogar y Estudiantes instalado, que no incluye Outlook, HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Office\14.0\Outlook estaba presente, pero no era HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\14.0\Outlook. Ahora he cambiado de código para buscar primero la versión "normal" no Wow6432Node. Si eso es presente, que va a ser utilizado. Si no es así, se seguirá observando la versión Wow6432Node. Esto se comprueba en un instalador basado en Inno Setup - No sé lo que APIs usos de Inno Setup. Si su aplicación no accede al registro de la misma manera, es posible obtener resultados diferentes.

escribí este para Outlook en un principio. Modificado un poco para Word, pero no va a trabajar en una instalación independiente porque esa clave no muestra el valor de bits, sólo se hace de Outlook.

Además, me escribió para soportar sólo las versiones actuales de Office, => 2010

Me desnudé todo el proceso de instalación y 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

En las pruebas que muchos de los enfoques descritos aquí fracaso, creo que porque se basan en las entradas en el registro de Windows que resultan ser no fiable presentes, dependiendo de la versión de Office, la forma en que se instaló etc Por lo tanto es un enfoque diferente a no utilizar el registro en absoluto (Ok, tan estrictamente que no hace que sea una respuesta a la pregunta planteada), pero en lugar de escribir un guión que:

  1. Crea una instancia de Excel
  2. Añade un libro de trabajo para esa instancia de Excel
  3. Añade un módulo de VBA a ese libro
  4. inyecta una pequeña función de VBA que devuelve el valor de bits de Office
  5. Las llamadas que la función
  6. Se limpia

Aquí es que el enfoque aplicado en 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. Este enfoque funciona más lentamente que otros aquí (unos 2 segundos en mi PC), pero podría llegar a ser más fiable a través de diferentes instalaciones y las versiones de Office.

Después de algunos meses, me he dado cuenta de que puede haber un enfoque más simple, aunque sigue siendo uno que instancia una instancia de Excel. El VBScript es: 

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

Esto se basa en el hecho de que Application.OperatingSystem, cuando se llama desde 32 bits Excel en Windows de 64 bits devuelve Windows (32-bit) NT 10.00 o al menos lo hace en mi PC. Pero eso no es mencionado en el docs .

Tengo win 7 64 bits + Excel 2010 de 32 bits. El registro es HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Office \ 14.0 \ Registro {90140000-002A-0000-1000-0000000FF1CE}

Así que esto puede indicar valor de bits del sistema operativo, no bitness de la oficina

He encontrado una manera segura y fiable en mi script basado en InnoSetup para entender si una aplicación en particular es de 32 bits o de 64 bits (en mi caso necesitaba para probar Excel), mediante el uso de una función API de Win32. Esta función se llama GetBinaryType(), se trata de `kernel32' (a pesar del nombre que viene con sabor a 32 y 64 bits) y mira directamente a la cabecera del exe.

Este artículo de Wikipedia estados:

  

En las versiones de 64 bits de Windows, hay dos carpetas para los archivos de aplicación; la carpeta "Program Files" contiene programas de 64 bits, y la carpeta "Program Files (x86)" contiene programas de 32 bits.

Así que si el programa está instalado en C:\Program Files que es una versión de 64 bits. Si se instala bajo C:\Program Files (x86) es una instalación de 32 bits.

Otra forma de detectar el valor de bits de Office es para averiguar la biblioteca de tipos.

Por ejemplo, para detectar valor de bits de Outlook, escribir un archivo .JS de la siguiente manera: 

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

Se puede encontrar fuera Identificación biblioteca de tipos de otro componente de Office, y vuelva a colocar la primera línea de la función para ello. He aquí una breve lista de ID interesantes: 

{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

Todo lo anterior Identificación del lib se encontraron a través de la herramienta de OLE-COM Object Viewer SDK de Windows, se puede encontrar más información lib de identificación mediante el uso de la misma.

La ventaja de este enfoque es que funciona para todas las versiones de la oficina, y proporciona un control en cada componente individual en le interesan. Por otra parte, esas llaves están en el HKEY_CLASSES_ROOT y profundamente integrados en el sistema, por lo que es muy poco probable que no eran accesibles incluso en un entorno de pruebas.

NOTA BIEN: La función detectVersion mencionados anteriormente no funciona . Tengo una versión de 64 bits de Office, y una separada con 32. Ambas versiones de usar esta función de retorno "32 bit".

Comprobación del registro de forma manual lleva a la misma conclusión:. Tanto de 64 y 32 bits (x64 Office 2010 y Office 2013 de 32 bits) reportan 32 bits

En lo personal creo que el equipo de la Oficina debería simplemente escribir y mantener una forma fácil de obtener la clave de registro en alguna parte. Todo el complemento de necesidad de hacer referencia a este, y en la actualidad "adivinar" es un enfoque pobres para que los desarrolladores se ven obligados a utilizar.

No es necesario que la escritura. Mira esta página que me encontré con:

https://social.msdn.microsoft.com/Forums/office/en-US/43499ae0-bcb5-4527- 8edb-f5a955987b56 / cómo-a-detectar-si-ms-instaladas-office-2010-es-32-o-64-bit? foro = worddev

Para resumir:

El cuarto campo en el código de producto indica el valor de bits del producto.

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

0 para x 86, 1 para x64 0-1 (Esto también es válido para MSOffice 2013)

buscar el registro para la ruta de instalación del componente de la oficina le interesa, por ejemplo, para Excel 2010 mirada en el software (Wow6432Node) \ Microsoft \ Office \ 14.0 \ Excel \ InstallRoot. Sólo será ya sea en el registro de 32 bits o el registro de 64 bits no tanto.

clave de registro

Outlook valor de bits no existe en mi máquina.

Una forma de determinar de Outlook valor de bits es mediante el examen de Outlook.exe sí mismo y determinar si es 32 o 64 bits.

Específicamente, se puede comprobar la [IMAGE_FILE_HEADER.Machine] [1] el tipo y esto devolverá un valor que indica el tipo de procesador.

Para un excelente fondo de esta discusión, al leer el encabezado de PE de un archivo de lectura presente (enlace obsoleta) , que establece;

La estructura IMAGE_NT_HEADERS es el lugar principal donde se almacenan las características específicas del archivo PE. Su desplazamiento está dado por el campo e_lfanew en el IMAGE_DOS_HEADER al principio del archivo. En realidad, hay dos versiones de la estructura IMAGE_NT_HEADER, uno para ejecutables de 32 bits y el otro para las versiones de 64 bits. Las diferencias son tan pequeñas que voy a considerar a ser el mismo para los propósitos de esta discusión. La única manera correcta, aprobada por Microsoft de diferenciar entre los dos formatos es a través del valor del campo mágico en el IMAGE_OPTIONAL_HEADER (descrito en breve).

Un IMAGE_NT_HEADER se compone de tres campos:

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

y se puede obtener el código C # aquí .

El Campo mágico se encuentra al principio de la estructura IMAGE_OPTIONAL_HEADER, 2 bytes en el desplazamiento 24 desde el inicio de las _IMAGE_NT_HEADERS. Tiene valores de 0x10B para 32 bits y 0x20B para 64 bits.

No es a través del registro, sino a través de herramientas de línea de comandos:

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

La mejor manera fácil:Coloque el ícono ACERCA DE en su aplicación Office 2016.Ejemplo de Excel

1) Abra Excel -> Archivo -> Opciones -> Personalizar cinta

2) Verás 2 paneles.Elija comandos y personalice la cinta

3) Desde Elegir comando, seleccione todos los comandos

4) De la lista resultante, resalte Acerca de (Excel)

5) Desde Personalizar la cinta de opciones, resalte cualquier elemento (ej.Ver) donde desea colocar el ícono Acerca de

6) Haga clic en Nuevo grupo en la parte inferior.

7) Haga clic en el botón Agregar ubicado entre los dos paneles.HECHO

Ahora, cuando haces clic en la pestaña Ver en Excel y haces clic en Acerca de, verás 32 bits o 64 bits.

He encontrado una manera mucho más fácil. El uso de Powershell, podemos conectar Excel como un 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

Al solicitar la OperatingSystem esta manera, obtenemos resultados extraños, echar un vistazo aquí. PC3 es la mía.

Espero que esto funcione para ustedes. Lo siento por la falta de códigos; mis guiones son en su mayoría funcional.

Editar No se olvide de agregar el código para cerrar Excel después de que haya terminado la recuperación de los datos.
Después de probar este código ayer tuve toneladas de apertura Excel y chocar de repente ..
Esto se asegurará de que usted mantener a los usuarios y los administradores feliz (: 

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

EDIT:. Solución sin tocar RegistryKeys - Lo siento Op

Me di cuenta de que hay una solución en C # - el original se puede encontrar aquí: https: / /blogs.msdn.microsoft.com/webdav_101/2016/07/26/sample-detecting-installed-outlook-and-its-bitness/

He modificado un poco para mis necesidades.

sólo tiene que pasar la outlookPath correcta de 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 uno quiere saber sólo qué número de bits es una versión instalada de Office 2010, en cualquier aplicación de Office 2010, simplemente haga clic en Archivo y luego en Ayuda.Aparecerá la información sobre el número de versión y, junto a ella, entre paréntesis, aparecerá (32 bits) o (64 bits).

Abra Outlook 2013> Archivo> cuenta de Office> Acerca del Panorama General> haga clic en el botón grande "? Acerca del Panorama General"> leer la descripción emergente

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top