Rileva se Office è a 32 bit o 64 bit tramite il registro

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

Domanda

Ora che Office è disponibile anche con installazione a 64 bit, dove trovi nel registro se la versione di Office installata è a 32 bit o 64 bit?

È stato utile?

Soluzione

Da articolo di TechNet su edizioni a 64 bit di Office 2010 :

  

Se si è installato Office 2010   tra cui Microsoft Outlook 2010,   Outlook imposta una chiave di registro di nome    bitness di tipo REG_SZ sul computer su cui è installato. Il    bitness chiave di registro indica se l'installazione di Outlook 2010   è 32 bit o 64 bit. Può essere   utile per gli amministratori che sono   interessati a computer di controllo a   determinare le versioni installate di   Office 2010 nella loro organizzazione.

     
      percorso
  • Registro: HKEY_LOCAL_MACHINE \ Software \ Microsoft \ Office \ 14.0 \ Outlook
    •   
  • se è stato installato Office 2013 quindi utilizzare questo     percorso del Registro di sistema: HKEY_LOCAL_MACHINE \ Software \ Microsoft \ Office \ 15.0 \ Outlook
    •   tasto
  • Registro: bitness
    •   
  • Valore: x86 o x64
    •   

e altrove nello stesso articolo:

  

A partire da Office 2010, Outlook è   disponibile come un'applicazione a 32 bit e   un'applicazione a 64 bit. La versione   (Numero di bit) di Outlook che si sceglie   dipende l'edizione di Windows   sistema operativo (32 bit o 64 bit)   e l'edizione di Office 2010 (a 32 o   64-bit) che è installato sul   computer, se Office è già   installato su quel computer.

     

I fattori che determinano la fattibilità   di installazione a 32 bit o 64 bit   versione di Outlook include il   seguenti:

     
      
  • È possibile installare a 32 bit di Office 2010 e 32-bit di Microsoft Outlook 2010 in un'edizione supportato a 32-bit o 64-bit del sistema operativo Windows. È possibile installare la versione a 64 bit di Office 2010 e 64 bit di Outlook 2010 solo su un sistema operativo a 64 bit supportato.
    •   
  • L'installazione di default di Office 2010 su una versione a 64 bit del sistema operativo Windows è a 32 bit di Office 2010.
    •   
  • Il numero di bit di una versione installata di Outlook è sempre lo stesso del numero di bit di Office 2010, se Office è installato sullo stesso computer. Cioè, una versione a 32 bit di Outlook 2010 non può essere installato sullo stesso computer su cui le applicazioni 2010 sono già installate versioni a 64 bit di altri Office, ad esempio a 64 bit di Microsoft Word 2010 o 64 bit di Microsoft Excel 2010. Allo stesso modo , una versione a 64 bit di Outlook 2010 non può essere installato sullo stesso computer su cui sono già installati versioni a 32 bit di altre applicazioni di Office.
    •   

Altri suggerimenti

Ho testato la risposta di Otaku e sembra che il valore bitness Outlook è impostato anche quando non è installato Outlook, anche se l'articolo citato non lo fa chiaramente indicano che questo sarebbe il caso.

Per aggiungere alla risposta di vtrz, ecco una funzione che ho scritto per 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;

duole dirlo, ma entrambi i metodi di @ clatonh di Otacku e non stanno lavorando per me - non hanno né Outlook bitness né {90140000-0011-0000- 1000 } -0000000FF1CE nel registro (per 64- Ufficio bit senza Outlook installato).

L'unico modo che ho trovato, però, non tramite il Registro di sistema, è quello di verificare bitness per uno dei file eseguibili di Office con l'uso della funzione API di Windows GetBinaryType (a partire da Windows 2000 Professional).

Per esempio, è possibile verificare il numero di bit di Winword.exe, quale percorso è memorizzato sotto
HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Windows \ CurrentVersion \ App Paths \ Winword.exe.

Ecco il codice MFC frammento: 

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
}

Attenzione:. Interrogando il numero di bit della applicazione Outlook non funziona correttamente se chiamati in ambiente .NET

Qui, usiamo GetBinaryType () in una DLL che può essere chiamato da qualsiasi applicazione:

  • Se l'applicazione host è a 64 bit C / C ++, GetBinaryType () restituisce SCS_32BIT_BINARY.
  • Se l'applicazione host è a 64 bit NET (abbiamo testato "AnyCPU" su un sistema a 64 bit), GetBinaryType () restituisce SCS_64BIT_BINARY.

Con esattamente lo stesso codice DLL ed esattamente lo stesso percorso binario Outlook. ( "C: / Program Files (x86) / ...") sullo stesso computer

Il che significa che potrebbe essere necessario per testare il file binario da soli, usando la voce "IMAGE_NT_HEADERS.FileHeader.Machine".

Dio, odio i valori di ritorno non corretti di alcune API di Windows (vedi anche GetVersion () si trovano).

ho trovato il modo per controllare l'ufficio bitness.

Possiamo controllare l'ufficio 365 e il 2016 bitness usando questa chiave di registro: 

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration

per piattaforma x86 per 32 bit. 

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration

x64 Platform for 64 bit.

Si prega di verificare ...

Ho trovato questo approccio:

Se HKLM \ Software \ WOW6432Node esiste quindi Windows è a 64 bit.

Se HKLM \ Software \ WOW6432Node \ Microsoft \ Office esiste, allora Ufficio è a 32 bit.

Se HKLM \ Software \ WOW6432Node \ Microsoft \ Office non esiste, ma HKLM \ Software \ Microsoft \ Office esiste, allora Ufficio è a 64 bit.

Se HKLM \ Software \ WOW6432Node non esiste, quindi Windows e Office sono a 32-bit.

Fonte: Technet Forum

Ecco quello che ero in grado di utilizzare in un VBscript per rilevare Ufficio 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

È possibile cercare il Registro di sistema per {90140000-0011-0000- 0000 -0000000FF1CE}. Se i numeri in grassetto iniziano con 0 la sua x86, x64 1 è

Per me è stato in HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Office \ 14.0 \ Registration {90140000-0057-0000-0000-0000000FF1CE}

Fonte

Questo codice InnoSetup sta lavorando per me sotto Win 10x64 e Office 2016 x86 (usando '\ SOFTWARE HKLM \ Microsoft \ Office \ ClickToRun \ Configuration' e il tasto '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;

Non ho una chiave denominata bitness in una di queste cartelle. Io ho una chiave denominata "default" in entrambe queste cartelle e il valore è "impostata" Il mio computer è venuto con Office 2010 Starter (presumo a 64 bit). Ho rimosso e ho cercato di fare un'installazione completa di 32 uffici bit. Continuo a ricevere il seguente messaggio. il file non è compatibile, controllare per vedere se è necessario x86 o x64 versione del programma.

qualche consiglio da darmi?

@clatonh: questo è il percorso del Registro di sistema sul mio PC: HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Office \ 14.0 \ Registration {90140000-002A-0000-1000-0000000FF1CE} ed è sicuramente un 32 bit-installazione su un sistema operativo a 64 bit.

Ho già ciecamente seguito la risposta in base alle documentazione MSDN. Oggi, questo si è rivelato essere meno di quanto richiesto. Su una macchina con Office Home e Student installato, che non include Outlook, HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Office\14.0\Outlook era presente, ma non era HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\14.0\Outlook. Ora ho cambiato il mio codice per cercare prima per la versione "normale" non Wow6432Node. Se questo è presente, verrà utilizzato. In caso contrario, continuerà, cercando in versione Wow6432Node. Questo viene controllato in un programma di installazione basato su Inno Setup - Non so che le API usi Setup Inno. Se la vostra applicazione non accede il Registro di sistema allo stesso modo, si potrebbe vedere risultati diversi.

Ho scritto questo per Outlook in un primo momento. Modificato un po 'per la parola, ma non funziona su un autonomo installare in quanto tale chiave non mostra il numero di bit, solo Outlook fa.

Inoltre, ho scritto per supportare solo le attuali versioni di Office, => 2010

ho messo a nudo tutta la messa a punto e post elaborazione ... 

: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

Nel mio test molti gli approcci descritti qui riesco, credo perché si basano su voci nel registro di Windows, che risultano essere non in modo affidabile presenti, a seconda della versione di Office, come è stato installato ecc Quindi un approccio diverso è di non utilizzare il registro di sistema a tutti (Ok, così strettamente che non lo rende una risposta alla domanda di posta), ma invece scrivere uno script che:

  1. Crea un'istanza di Excel
  2. Aggiunge una cartella di lavoro a tale istanza di Excel
  3. Aggiunge un modulo VBA a quella cartella di lavoro
  4. inietta una piccola funzione VBA che restituisce il numero di bit di Office
  5. Chiamate che la funzione
  6. Pulisce

Ecco che l'approccio implementato in 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. Questo approccio funziona più lentamente di altri qui (circa 2 secondi sul mio PC), ma potrebbe rivelarsi più affidabili tra le diverse installazioni e le versioni di Office.

Dopo alcuni mesi, mi sono reso conto ci può essere un approccio più semplice, anche se ancora uno che crea un'istanza di un'istanza di Excel. Il 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

Questo si basa sul fatto che Application.OperatingSystem, quando viene chiamato da 32 bit di Excel a 64 bit Windows restituisce Windows (32-bit) NT 10.00 o almeno lo fa sul mio PC. Ma questo non è menzionato nella docs .

Non ho vincere 7 a 64 bit + Excel 2010 a 32 bit. Il registro è HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Office \ 14.0 \ Registration {90140000-002A-0000-1000-0000000FF1CE}

Quindi questo può dire bitness del sistema operativo, non bitness di Office

Ho trovato un modo sicuro e affidabile nel mio script InnoSetup-based per capire se una particolare applicazione è a 32-bit o 64-bit (nel mio caso avevo bisogno di testare Excel), utilizzando una funzione API Win32. Questa funzione è chiamata GetBinaryType(), viene da `kernel32' (nonostante il nome si tratta di sapore 32 e 64 bit) e guarda direttamente nell'intestazione del exe.

questo articolo di Wikipedia stati:

  

Nelle versioni a 64 bit di Windows, ci sono due cartelle per i file applicativi; la cartella "Program Files" contiene programmi a 64 bit, e la cartella "Program Files (x86)" contiene programmi a 32 bit.

Quindi, se il programma è installato sotto C:\Program Files si tratta di una versione a 64 bit. Se è installato sotto C:\Program Files (x86) si tratta di un'installazione a 32 bit.

Un altro modo per rilevare il numero di bit di Office è quello di scoprire la libreria dei tipi.

Ad esempio, per rilevare bitness di Outlook, scrivere un file JS come segue: 

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

Si potrebbe scoprire di altro componente dell'Ufficio libreria dei tipi id, e sostituire la prima riga della funzione per esso. Ecco un breve elenco di ID interessanti: 

{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

Tutti sopra id lib sono stati trovati attraverso lo strumento OLE-COM Object Viewer SDK di Windows, è possibile saperne di più lib id usandolo.

Il vantaggio di questo approccio è che funziona per tutte le versioni di Office e fornisce il controllo su ogni singolo componente nel vostro interesse. Inoltre, queste chiavi sono in HKEY_CLASSES_ROOT e profondamente integrati nel sistema, quindi è altamente improbabile che non erano accessibili anche in un ambiente sandbox.

NOTA BENE: La funzione di cui sopra detectVersion non funziona . Ho una versione a 64 bit di Office, e uno separato con 32. Entrambe le versioni di utilizzare questa funzione di ritorno "32 bit".

Controllo del Registro di porta manualmente alla stessa conclusione:. Sia a 64 e 32 bit (Office 2010 e Office 2013 x64 a 32 bit) segnalare 32 bit

Personalmente penso che la squadra Ufficio dovrebbe semplicemente scrivere e mantenere un facile da ottenere la chiave di registro da qualche parte. Tutti add-in di necessità di fare riferimento a questo, e attualmente "indovinare" è un approccio povero per gli sviluppatori di essere costretti ad utilizzare.

Non è necessario per lo script di esso. Guardate questa pagina che mi sono imbattuto in:

https://social.msdn.microsoft.com/Forums/office/en-US/43499ae0-bcb5-4527- 8edb-f5a955987b56 / how-to-detect-se-installate-MS-office-2010-è-32-o-64-bit? forum = worddev

Per riassumere:

Il quarto campo nel ProductCode indica il numero di bit del prodotto.

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

0 per x 86, 1 per x64 0-1 (Questo vale anche per MSOffice 2013)

Cerca nel Registro di sistema per il percorso di installazione del componente dell'ufficio che ti interessa, ad esempio, per Excel 2010 sguardo SOFTWARE (Wow6432Node) \ Microsoft \ Office \ 14.0 \ Excel \ InstallRoot. Sarà solo nel Registro di sistema a 32 bit o il Registro di sistema a 64 bit non entrambi.

chiave di registro

Outlook bitness non esiste sulla mia macchina.

Un modo per determinare Outlook bitness è esaminando Outlook.exe, se stessa e determinare se è 32bit o 64bit.

In particolare, è possibile controllare la [IMAGE_FILE_HEADER.Machine] [1] digitare e questo restituirà un valore che indica il tipo di processore.

Per un eccellente background di questa discussione, leggendo l'intestazione PE di un file di lettura questo (link obsoleto) , in cui si afferma;

La struttura IMAGE_NT_HEADERS è il luogo primario in cui sono memorizzati specifiche del file PE. La sua si specifica un offset dal campo e_lfanew nel IMAGE_DOS_HEADER all'inizio del file. In realtà ci sono due versioni della struttura IMAGE_NT_HEADER, uno per gli eseguibili a 32 bit e l'altra per le versioni a 64 bit. Le differenze sono così piccola che io considero loro di essere lo stesso per i fini di questa discussione. L'unico modo corretto di Microsoft-approvato di differenziare tra i due formati è tramite il valore del campo Magia nel IMAGE_OPTIONAL_HEADER (descritto poco).

Un IMAGE_NT_HEADER è composto da tre campi:

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

e si può ottenere il codice C # qui .

Il campo Magic è all'inizio della struttura IMAGE_OPTIONAL_HEADER, 2 byte all'offset 24 dall'inizio delle _IMAGE_NT_HEADERS. Ha valori di 0x10B per 32 bit e 0x20B 64-bit.

Non tramite il Registro di sistema, ma attraverso gli strumenti a riga di 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"

Miglior modo semplice: inserire l'icona INFO sul tuo Ufficio 2016 Application. Esempio Excel

1) Aprire Excel -> File -> Opzioni -> Personalizza barra multifunzione

2) You 'll vedere 2 riquadri. Scegliere Comandi Dalla & personalizzare la barra multifunzione

3) Da scegliere Comando, selezionare Tutti i comandi

4) dall'elenco risultante Highlight Chi (Excel)

5) Dal personalizzare la barra multifunzione Pain, evidenziare qualsiasi oggetto (es. View) in cui si desidera inserire l'icona About

6) Fare clic su Nuovo gruppo in fondo

7) Fare clic sul pulsante Aggiungi che si trova tra i due riquadro. Fine

Ora, quando si fa clic sulla scheda Visualizza in Excel e fare clic su vedrete a 32 bit o 64 bit

Ho trovato un modo molto più semplice. Utilizzando PowerShell, siamo in grado di agganciare Excel come un oggetto 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

Quando si richiede l'OperatingSystem in questo modo, si ottengono risultati strani, dare un'occhiata qui. PC3 è mio.

Spero che questo funziona per voi ragazzi. Ci scusiamo per la mancanza di codice; i miei script sono per lo più funzionali.

Modifica : Non dimenticate di aggiungere il codice per chiudere Excel dopo aver finito il recupero dei dati.
Dopo aver testato questo codice ieri ho avuto tonnellate di apertura Excel e schiantarsi tutto ad un tratto ..
Questo farà in modo che manterrai utenti e gli amministratori felice (: 

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

EDIT:. Soluzione senza toccare RegistryKeys - Mi dispiace Op

ho scoperto che c'è una soluzione in C # - l'originale si trova qui: https: / /blogs.msdn.microsoft.com/webdav_101/2016/07/26/sample-detecting-installed-outlook-and-its-bitness/

ho modificato un po 'per le mie esigenze.

basta passare il corretto outlookPath a 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 si vuole sapere solo qual è il numero di bit di una versione installata di Office 2010, in qualsiasi applicazione di Office 2010 è sufficiente fare clic su File, quindi su Guida.Verranno elencate le informazioni sul numero di versione e accanto, tra parentesi, sarà (32 bit) o ​​(64 bit).

Apri Outlook 2013> File> account Office> A proposito di Outlook> cliccare grande pulsante "? Chi Outlook"> leggi descrizione pop-up

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top