wake-up-neo.com

Stellen Sie über die Registrierung fest, ob Office 32 Bit oder 64 Bit ist

Nun, da Office auch in einer 64-Bit-Installation enthalten ist, finden Sie in der Registrierung heraus, ob die installierte Office-Version 32-Bit oder 64-Bit ist.

50

Im TechNet-Artikel zu 64-Bit-Editionen von Office 2010 :

Wenn Sie Office 2010 installiert haben einschließlich Microsoft Outlook 2010, Outlook legt einen Registrierungsschlüssel mit dem Namen .__ fest. Bitness vom Typ REG_SZ auf dem Computer, auf dem es installiert ist. Das Der Registrierungsschlüssel Bitness gibt an, ob die Outlook 2010-Installation ist 32-Bit oder 64-Bit. Das mag sein nützlich für Administratoren, die .__ sind. Interesse an der Überprüfung von Computern auf Ermitteln Sie die installierten Versionen von Office 2010 in ihrer Organisation.

  • Registrierungspfad: HKEY_LOCAL_MACHINE\Software\Microsoft\Office\14.0\Outlook
  • wenn Sie Office 2013 installiert haben, verwenden Sie diese Registrierungspfad: HKEY_LOCAL_MACHINE\Software\Microsoft\Office\15.0\Outlook
  • Registrierungsschlüssel: Zeuge
  • Wert: entweder x86 oder x64

und an anderer Stelle im selben Artikel:

Outlook beginnt mit Office 2010 verfügbar als 32-Bit-Anwendung und eine 64-Bit-Anwendung. Die Version (bitness) von Outlook, das Sie wählen hängt von der Edition des Windows ab Betriebssystem (32-Bit oder 64-Bit) und die Edition von Office 2010 (32- oder 64-Bit-Version), die auf der .__-Komponente installiert ist. Computer, wenn Office bereits vorhanden ist auf diesem Computer installiert.

Faktoren, die die Machbarkeit bestimmen der Installation eines 32-Bit oder eines 64-Bit Version von Outlook enthalten die folgende:

  • Sie können 32-Bit-Office 2010 und 32-Bit-Microsoft Outlook 2010 auf einer unterstützten 32-Bit- oder 64-Bit-Edition des Windows-Betriebssystems installieren. Sie können die 64-Bit-Version von Office 2010 und 64-Bit-Outlook 2010 nur auf einem unterstützten 64-Bit-Betriebssystem installieren.
  • Die Standardinstallation von Office 2010 auf einer 64-Bit-Edition des Windows-Betriebssystems ist 32-Bit-Office 2010.
  • Die Bitness einer installierten Version von Outlook ist immer die gleiche wie die von Office 2010, wenn Office auf demselben Computer installiert ist. Das bedeutet, dass eine 32-Bit-Version von Outlook 2010 nicht auf demselben Computer installiert werden kann, auf dem bereits 64-Bit-Versionen anderer Office 2010-Anwendungen installiert sind, z. B. Microsoft Word 2010 (64-Bit) oder Microsoft Excel 2010 (64-Bit) Eine 64-Bit-Version von Outlook 2010 kann nicht auf demselben Computer installiert werden, auf dem bereits 32-Bit-Versionen anderer Office-Anwendungen installiert sind.
49
Todd Main

Ich habe die Antwort von Otaku getestet und es scheint, dass der Outlook-Bitness-Wert auch dann gesetzt ist, wenn Outlook nicht installiert ist, auch wenn der Artikel, auf den verwiesen wird, nicht eindeutig darauf hinweist, dass dies der Fall ist.

23
TodK

Um vtrz's Antwort hinzuzufügen, habe ich hier eine Funktion geschrieben, die ich für Inno Setup geschrieben habe:

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 '[email protected] 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;
9
MB.

Bedauern Sie zu sagen, aber die Methoden von Otacku und @ clatonh funktionieren für mich nicht - weder Outlook Bitness noch {90140000-0011-0000 -1000 -0000000FF1CE} in der Registrierung (für 64-Bit-Office ohne installiertes Outlook) . 

Der einzige Weg, den ich jedoch nicht über die Registrierung gefunden habe, ist die Überprüfung der Bitness für eine der ausführbaren Office-Dateien mithilfe der Windows-API-Funktion GetBinaryType (seit Windows 2000 Professional). 

Beispielsweise können Sie die Bitness von Winword.exe überprüfen, unter welchem ​​Pfad gespeichert wird
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\Winword.exe.

Hier ist das MFC-Codefragment:

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
}
8
vtrz

Achtung: Abfragen der Bitness der Outlook-Anwendung funktioniert NICHT zuverlässig wenn in .NET-Umgebung aufgerufen.

Hier verwenden wir GetBinaryType () in einer DLL, die von jeder Anwendung aufgerufen werden kann:

  • Wenn die Host-Anwendung 64-Bit-C/C++ ist, gibt GetBinaryType () SCS_32BIT_BINARY zurück.
  • Wenn die Host-Anwendung 64-Bit-.NET ist (wir haben "AnyCPU" auf einem 64-Bit-System getestet), gibt GetBinaryType () SCS_64BIT_BINARY zurück.

Mit exakt demselben DLL - Code und genau demselben Outlook-Binärpfad ("c:/Programme (x86)/...") auf demselben Computer.

Das bedeutet, dass Sie die Binärdatei möglicherweise mit dem Eintrag "IMAGE_NT_HEADERS.FileHeader.Machine" selbst testen müssen.

Ich hasse die falschen Rückgabewerte einiger Windows-APIs (siehe auch GetVersion ()).

5
chksr

Ich habe diesen Ansatz gefunden:

Wenn HKLM\Software\WOW6432Node vorhanden ist, ist Windows 64-Bit.

Wenn HKLM\Software\WOW6432Node\Microsoft\Office vorhanden ist, ist Office 32-Bit.

Wenn HKLM\Software\WOW6432Node\Microsoft\Office nicht vorhanden ist, HKLM\Software\Microsoft\Office jedoch existiert, ist Office 64-Bit.

Wenn HKLM\Software\WOW6432Node nicht vorhanden ist, sind Windows und Office 32-Bit.

Quelle: Technet-Foren

3
Jon Peltier

Ich habe den Weg gefunden, um die Büro-Bitness zu überprüfen.

Wir können die Office 365- und 2016-Bitness mit diesem Registrierungsschlüssel überprüfen:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration

Plattform x86 für 32 Bit.

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration

Plattform x64 für 64 Bit.

Bitte prüfe...

2
chetan yamger

Folgendes konnte ich in einem VBscript zur Erkennung von Office 64-Bit-Outlook verwenden:

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
2
uflrob

Dieser InnoSetup-Code funktioniert für mich unter Win 10x64 und Office 2016 x86 (verwendet "HKLM\SOFTWARE\Microsoft\Office\ClickToRun\Configuration" und den Schlüssel "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;
2

Sie können die Registrierung nach {90140000-0011-0000 -0000 -0000000FF1CE} durchsuchen. Wenn die fetten Zahlen mit 0 beginnen, ist x86, 1 ist x64 

Für mich war es in HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\14.0\Registration {90140000-0057-0000-0000-0000000FF1CE}

Quelle

2

Ich habe in keinem dieser Ordner einen Schlüssel namens bitness. Ich habe in beiden Ordnern einen Schlüssel namens "default" und der Wert ist "unset". Ich entfernte es und versuchte eine vollständige Installation von 32-Bit-Office. Ich erhalte die folgende Nachricht. Die Datei ist nicht kompatibel. Überprüfen Sie, ob Sie eine x86- oder x64-Version des Programms benötigen.

irgendein Rat für mich

1
dave

In meinen Tests schlagen viele der hier beschriebenen Ansätze fehl, ich denke, da sie auf Einträge in der Windows-Registrierung angewiesen sind, die sich als nicht zuverlässig präsentieren, abhängig von der Office-Version, der Art der Installation usw. Daher ist ein anderer Ansatz nicht anzuwenden die Registry überhaupt (Ok, so streng, dass es keine Antwort auf die Frage als gestellt darstellt), sondern schreibe ein Skript, das:

  1. Instantiiert Excel
  2. Fügt dieser Excel-Instanz eine Arbeitsmappe hinzu
  3. Fügt dieser Arbeitsmappe ein VBA-Modul hinzu
  4. Fügt eine kleine VBA-Funktion ein, die die Bit-Zahl von Office zurückgibt
  5. Ruft diese Funktion auf
  6. Saubermachen

Dieser Ansatz wurde in VBScript implementiert:

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. Dieser Ansatz läuft langsamer als andere (etwa zwei Sekunden auf meinem PC), erweist sich jedoch bei verschiedenen Installationen und Office-Versionen als zuverlässiger.

1
Philip Swannell

@clatonh: Dies ist der Pfad der Registrierung auf meinem PC: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\14.0\Registration {90140000-002A-0000-1000-0000000FF1CE}. Installation auf einem 64-Bit-Betriebssystem. 

1
Randolf

Ich habe die Antwort, die auf den MSDN-Dokumenten basiert, blind gefolgt. Dies stellte sich heute als weniger als erforderlich heraus. Auf einem Computer mit Office Home und Student, auf dem Outlook installiert ist, war HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Office\14.0\Outlook vorhanden, HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\14.0\Outlook jedoch nicht. Ich habe jetzt meinen Code geändert, um zuerst nach der "einfachen" Nicht-Wow6432Node-Version zu suchen. Wenn das vorhanden ist, wird es verwendet. Wenn nicht, wird die Wow6432Node-Version angezeigt. Dies wird in einem Inno Setup-basierten Installationsprogramm überprüft. Ich weiß nicht, welche APIs Inno Setup verwendet. Wenn Ihre App nicht auf dieselbe Weise auf die Registrierung zugreift, werden möglicherweise andere Ergebnisse angezeigt.

1
Jon Bright

Das habe ich zuerst für Outlook geschrieben. Es wurde ein wenig für Word geändert, funktioniert jedoch nicht bei einer eigenständigen Installation, da der Schlüssel nicht die Bitness anzeigt, nur Outlook.

Ich habe es auch so geschrieben, dass es nur aktuelle Versionen von Office unterstützt, => 2010

Ich entfernte alle Einstellungen und Nachbearbeitungen ...

: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
1
Dean H.

EDIT: Lösung ohne RegistryKeys zu berühren - im Sorry Op.

Ich fand heraus, dass es eine Lösung in C # gibt - das Original ist hier zu finden: https://blogs.msdn.Microsoft.com/webdav_101/2016/07/26/sample-detecting-installed-Outlook-and- seine Bissigkeit/

Ich habe es ein wenig an meine Bedürfnisse angepasst.

übergebe einfach den korrekten outlookPath an 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;



    }
0
Schmiddi1004

Ich habe einen viel einfacheren Weg gefunden. Mit Powershell können wir Excel als COM-Objekt verknüpfen.

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

Wenn Sie das OperatingSystem auf diese Weise anfordern, erhalten wir seltsame Ergebnisse sehen Sie hier. PC3 gehört mir.

Ich hoffe, das funktioniert für euch. Entschuldigung für den fehlenden Code. Meine Skripte sind größtenteils funktional.

Edit: Vergessen Sie nicht, den Code zum Schließen von Excel hinzuzufügen, nachdem Sie die Daten abgerufen haben.
Nachdem ich gestern diesen Code getestet hatte, hatte ich tonnenweise Excel geöffnet und war plötzlich abgestürzt.
Dies wird sicherstellen, dass Sie Benutzer und Admins glücklich halten (:

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

Dieser Wikipedia-Artikel besagt:

In 64-Bit-Versionen von Windows gibt es zwei Ordner für Anwendungsdateien. Der Ordner "Program Files" enthält 64-Bit-Programme und der Ordner "Program Files (x86)" enthält 32-Bit-Programme.

Wenn das Programm also unter C:\Program Files installiert ist, handelt es sich um eine 64-Bit-Version. Wenn es unter C:\Program Files (x86) installiert ist, handelt es sich um eine 32-Bit-Installation.

0
George Dean

Eine weitere Möglichkeit, die Bitness von Office zu erkennen, besteht darin, die Typelib herauszufinden. 

Um beispielsweise die Bitgröße von Outlook zu erkennen, schreiben Sie eine JS-Datei wie folgt:

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

Sie können die Typelib-ID einer anderen Office-Komponente ermitteln und die erste Zeile der Funktion dafür ersetzen. Hier ist eine kurze Liste interessanter IDs:

{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

Alle obigen lib-IDs wurden mit dem Windows SDK-Tool OLE-COM Object Viewer gefunden. Sie können weitere lib-IDs finden, indem Sie sie verwenden.

Der Vorteil dieses Ansatzes ist, dass er für alle Office-Versionen geeignet ist und die Kontrolle über jede einzelne Komponente in Ihrem Interesse bietet. Darüber hinaus befinden sich diese Schlüssel in der HKEY_CLASSES_ROOT und sind tief in das System integriert. Es ist daher höchst unwahrscheinlich, dass sie auch in einer Sandbox-Umgebung nicht zugänglich waren. 

0
Earth Engine

Ich habe in meinem InnoSetup-basierten Skript einen sicheren und zuverlässigen Weg gefunden, anhand einer Win32-API-Funktion zu ermitteln, ob eine bestimmte Anwendung 32-Bit oder 64-Bit ist (in meinem Fall musste ich Excel testen). Diese Funktion heißt GetBinaryType(), sie stammt von 'kernel32' (trotz des Namens, in dem sie 32 und 64 Bit enthält) und schaut direkt in den Header der Exe.

0
Dutch Gemini

HINWEIS: Die oben angegebene Erkennungsversion funktioniert nicht . Ich habe eine 64-Bit-Version von Office und eine separate mit 32. Beide Versionen, die diese Funktion verwenden, geben "32-Bit" zurück.

Das manuelle Überprüfen der Registrierung führt zu der gleichen Schlussfolgerung: Sowohl 64 als auch 32-Bit (Office 2010 x64 und Office 2013 32-Bit) melden 32 Bit.

Ich persönlich denke, das Office-Team sollte einfach irgendwo einen einfach zu beschreibenden Registrierungsschlüssel schreiben und verwalten. Alle Add-Ins müssen darauf hinweisen, und das "Erraten" ist für Entwickler ein schlechter Ansatz, der gezwungen wird, sie zu verwenden.

0
David Ford

Sie brauchen es nicht zu schreiben. Schauen Sie sich diese Seite an, auf die ich gestoßen bin: 

https://social.msdn.Microsoft.com/Forums/office/de/43499ae0-bcb5-4527-8edb-f5a955987b56/wie-den-detektor-ohne-installiert-ms-office-2010-is- 32-oder-64-Bit? Forum = worddev

Zusammenfassen: 

Das vierte Feld im Produktcode gibt die Bittheit des Produkts an.

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

0 für x86, 1 für x64 0-1 (Dies gilt auch für MSOffice 2013)

0
Larry S-W

Nicht über die Registry, sondern über Kommandozeilen-Tools:

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:\Programme (x86)\Microsoft Office\Root\Office16\Outlook.EXE"/f "% 1"

0
fiffy

Am besten einfach: Setzen Sie das ABOUT-Symbol in Ihre Office 2016-Anwendung. Beispiel Excel

1) Öffnen Sie Excel -> Datei -> Optionen -> Multifunktionsleiste

2) Sie sehen 2 Fenster. Wählen Sie Befehle aus und passen Sie das Menüband an

3) Wählen Sie unter Choose Command Alle Befehle aus

4) Markieren Sie in der resultierenden Liste "Info" (Excel).

5) Markieren Sie unter Anpassen des Farbband-Schmerzes alle Elemente (z. B. Ansicht), an denen Sie das Info-Symbol einfügen möchten

6) Klicken Sie unten auf Neue Gruppe

7) Klicken Sie auf die Schaltfläche Hinzufügen, die sich zwischen den beiden Bereichen befindet. ERLEDIGT

Wenn Sie nun auf die Registerkarte Ansicht in Excel klicken und auf ungefähr klicken, wird 32 Bit oder 64 Bit angezeigt

0
Charlie I.

Ich habe 7 64 Bit + Excel 2010 32 Bit gewonnen. Die Registrierung lautet HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\14.0\Registration {90140000-002A-0000-1000-0000000FF1CE}.

Dies kann also die Bitness des Betriebssystems und nicht die Officeness erkennen

0
toosensitive

Der Outlook-Zeuge-Registrierungsschlüssel ist auf meinem Computer nicht vorhanden.

Eine Möglichkeit, Outlook Bitness zu ermitteln, besteht darin, Outlook.exe selbst zu prüfen und festzustellen, ob es sich um 32-Bit- oder 64-Bit-Dateien handelt. 

Insbesondere können Sie den Typ [IMAGE_FILE_HEADER.Machine] [1] überprüfen, und dies gibt einen Wert zurück, der den Prozessortyp angibt.

Für einen hervorragenden Hintergrund dieser Diskussion, lesen Sie den PE-Header einer Datei: read this (veralteter Link)

Die IMAGE_NT_HEADERS-Struktur ist der primäre Speicherort, an dem Besonderheiten der PE-Datei gespeichert werden. Sein Offset wird durch das Feld e_lfanew in IMAGE_DOS_HEADER am Anfang der Datei angegeben. Es gibt tatsächlich zwei Versionen der IMAGE_NT_HEADER-Struktur, eine für ausführbare 32-Bit-Dateien und die andere für 64-Bit-Versionen. Die Unterschiede sind so gering, dass ich sie für die Zwecke dieser Diskussion als gleich empfinde. Die einzig richtige, von Microsoft genehmigte Möglichkeit, zwischen den beiden Formaten zu unterscheiden, ist über den Wert des Felds Magic in IMAGE_OPTIONAL_HEADER (in Kürze beschrieben).

Ein IMAGE_NT_HEADER besteht aus drei Feldern:

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

und Sie können den c # -Code hier bekommen.

Das Magic-Feld befindet sich am Anfang der IMAGE_OPTIONAL_HEADER-Struktur, 2 Bytes am Offset 24 vom Beginn des _IMAGE_NT_HEADERS. Es hat Werte von 0x10B für 32-Bit und 0x20B für 64-Bit.

0
Markus Hooge

Suchen Sie in der Registrierung nach dem Installationspfad der Office-Komponente, an der Sie interessiert sind, z. Für Excel 2010 schauen Sie in SOFTWARE (Wow6432Node)\Microsoft\Office\14.0\Excel\InstallRoot nach. Es wird nur entweder in der 32-Bit-Registry oder in der 64-Bit-Registry nicht beides sein.

0
Phil