Ermitteln Sie über die Registrierung, ob Office 32-Bit oder 64-Bit ist

https://stackoverflow.com/questions/2203980

18-09-2019
|

Frage

Jetzt, da Office auch in einer 64-Bit-Installation verfügbar ist, wo in der Registrierung können Sie herausfinden, ob es sich bei der installierten Office-Version um eine 32-Bit- oder eine 64-Bit-Version handelt?

Lösung

Von TechNet-Artikel über :

Wenn Sie Office 2010 installiert haben   einschließlich Microsoft Outlook 2010,   Outlook legt einen Registrierungsschlüssel mit dem Namen    Bitness vom Typ REG_SZ auf dem Computer, auf dem es installiert ist. Das    Bitness Registrierungsschlüssel gibt an, ob die Outlook 2010-Installation   ist 32-Bit oder 64-Bit. Das mag sein   nützliche Administratoren, die sind   Interesse an Wirtschaftsprüfungs Computern   bestimmen die installierten Versionen von   Office 2010 in ihrer Organisation.


Registrierungspfad: HKEY_LOCAL_MACHINE \ Software \ Microsoft \ Office \ 14.0 \ Outlook

Wenn Sie Office installiert haben 2013 dann verwenden Sie diese     Registrierungspfad: HKEY_LOCAL_MACHINE \ Software \ Microsoft \ Office \ 15.0 \ Outlook

Registrierungsschlüssel: Bitness

Wert: entweder x86 oder x64

und an anderer Stelle im selben Artikel:

Beginnend mit Office 2010, Outlook ist   verfügbar als 32-Bit-Anwendung und   eine 64-Bit-Anwendung. Die Version   (Bitness) von Outlook, die Sie wählen,   ist abhängig von der Edition des Windows   Betriebssystem (32-Bit- oder 64-Bit)   und die Ausgabe von Office 2010 (32- oder   64-Bit), die auf der installiert ist   Computer, wenn Office bereits   installiert auf dem Computer.

Faktoren, die die Machbarkeit bestimmen   der Einbau eines 32-Bit- oder eine 64-Bit   Outlook-Version umfasst die   Folgendes ein:


Sie können 32-Bit-Office 2010 und 32-Bit-Microsoft Outlook 2010 auf einem unterstützten 32-Bit- oder 64-Bit-Version des Windows-Betriebssystem 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 Standard-Installation von Office 2010 auf einem 64-Bit-Version des Windows-Betriebssystem 32-Bit-Office 2010.

Die Bitanzahl einer installierten Version von Outlook ist immer das gleiche wie die Bitness von Office 2010, wenn Office auf demselben Computer installiert ist. Das heißt, eine 32-Bit-Version von Outlook 2010 kann nicht auf demselben Computer installiert werden, auf dem 64-Bit-Versionen von anderem Office-2010-Anwendungen bereits installiert sind, wie 64-Bit-Microsoft Word 2010 oder 64-Bit-Microsoft Excel 2010. In ähnlichen , eine 64-Bit-Version von Outlook 2010 kann nicht auf demselben Computer installiert werden, auf dem 32-Bit-Versionen von anderen Office-Anwendungen sind bereits installiert.

Andere Tipps

Ich habe Otaku Antwort getestet und es scheint, dass der Outlook Bitness Wert selbst gesetzt wird, wenn Outlook nicht installiert ist, auch wenn der Artikel verwiesen wird nicht deutlich, dass dies der Fall sein würde.

Um zu vtrz Antwort hinzuzufügen, hier ist eine Funktion, die ich für Inno Setup schrieb:

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;

Leider funktionieren die Methoden von Otacku und @clatonh bei mir nicht – weder Outlook Bitness noch {90140000-0011-0000-1000-0000000FF1CE} in der Registrierung (für 64-Bit-Office ohne installiertes Outlook).

Die einzige Möglichkeit, die ich jedoch nicht über die Registrierung gefunden habe, besteht darin, die Bitanzahl für eine der ausführbaren Office-Dateien mithilfe der Windows-API-Funktion zu überprüfen GetBinaryType (seit Windows 2000 Professional).

Sie können beispielsweise die Bitanzahl von Winword.exe überprüfen, unter dem der Pfad gespeichert ist
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
}

. Achtung: die Bitness der Outlook-Anwendung Abfrage arbeitet nicht zuverlässig , wenn in .NET-Umgebung namens

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

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

Mit genau der gleichen DLL-Code und genau das gleiche Outlook binären Pfad. ( "C: / Program Files (x86) / ...") auf demselben Computer

Was bedeutet, dass Sie die Binärdatei selbst mit „IMAGE_NT_HEADERS.FileHeader.Machine“ -Eintrag testen benötigen.

Gott, ich hasse die falschen Rückgabewerte von einigen Windows-APIs (siehe auch GetVersion () liegt).

ich den Weg für die Überprüfung Büro Bitness gefunden.

Wir überprüfen Büro 365 und 2016 Bitness dieser Registrierungsschlüssel:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration

Plattform x86 für 32 Bit.

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration

Platform x64 64 Bit.

Bitte überprüfen Sie ...

Ich fand diesen Ansatz:

Wenn HKLM \ Software \ WOW6432Node existiert dann auf Windows-64-Bit.

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

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

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

Quelle: Technet Foren

Hier ist, was ich in der Lage war, in einem VBscript verwenden, um Office 64-Bit-Outlook zu ermitteln:

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

Sie können die Registrierung für die Suche {90140000-0011-0000- 0000 -0000000FF1CE}. Wenn die fetten Nummern mit 0 seiner x86 starten, 1 x 64

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

Quelle

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

Ich habe keinen Schlüssel Bitness in einem dieser Ordner genannt. Ich habe eine Taste „default“ in diesen beiden Ordnern aufgerufen und der Wert „nicht gesetzt“ Mein Computer kam mit Office 2010 Starter (ich nehme an 64-Bit). Ich entfernte sie und versuchte, eine vollständige Installation von 32-Bit-Büro zu tun. Ich erhalte die folgende Meldung. die Datei nicht kompatibel ist, überprüfen Sie, ob Sie x86 oder x64-Version des Programms benötigen.

ein Rat für mich?

@clatonh: Das ist der Weg der Registrierung auf meinem PC: HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Office \ 14.0 \ Registration {90140000-002A-0000-1000-0000000FF1CE} und es ist auf jeden Fall eine 32-Bit-Installation auf einem 64-Bit-Betriebssystem.

Ich habe gefolgt vorher blind die Antwort auf der Grundlage der MSDN-Dokumentation. Heute stellte sich diese geringer aus als erforderlich. Auf einer Maschine mit Office Home and Student installiert, die Outlook nicht enthalten war HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Office\14.0\Outlook vorhanden, aber HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\14.0\Outlook war es nicht. Ich habe jetzt meinen Code den ersten Blick für die „plain“ Nicht-Wow6432Node Version geändert. Wenn das vorhanden ist, wird es verwendet werden. Wenn nicht, wird es durch einen Blick auf die Wow6432Node Version fortzusetzen. Dies wird in einem Inno Setup-basierten Installationsprogramm überprüft - ich weiß nicht, welchen Inno Setup verwendet APIs. Wenn Ihre App greifen nicht auf die Registrierung in der gleichen Art und Weise, können Sie verschiedene Ergebnisse sehen.

Ich schrieb dies für Outlook auf den ersten. Modifizierte es ein wenig für Wort, aber es wird auf einem Standalone nicht funktionieren installieren, da die Schlüssel nicht die Bitness nicht zeigen, nur Outlook funktioniert.

Auch ich schrieb es nur die aktuellen Versionen von Office zu unterstützen, => 2010

Ich zog die ganze Einrichtung und Nachverarbeitung ...

: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

In meinen Tests viele der Ansätze hier nicht beschrieben, denke ich, weil sie auf Einträge in der Windows-Registrierung verlassen, die nicht zuverlässig vorhanden entpuppen, auf Office-Version abhängig, wie es installiert wurde etc. So ein anderer Ansatz ist die Registrierung nicht überhaupt zu verwenden (Ok, so streng, dass es nicht eine Antwort auf die Frage aufgeworfen macht), sondern stattdessen ein Skript schreiben, dass:

Instanziiert Excel
Fügt eine Arbeitsmappe, die Excel-Instanz
Fügt einen VBA-Modul zu der Arbeitsmappe
Injiziert eine kleine VBA-Funktion, die die Bitness von Office
Anrufe, die Funktion
Säubert

Hier ist, diesen Ansatz 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 hier (ca. 2 Sekunden auf meinem PC), aber es könnte zuverlässige über verschiedene Installationen und Office-Versionen entpuppt.

Nach einigen Monaten habe ich realisiert es kann ein einfacher Ansatz, obwohl man noch die eine Excel-Instanz instanziiert. Das VBScript ist:

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

Dies beruht auf der Tatsache, dass Application.OperatingSystem, wenn sie von 32-Bit-Excel auf 64-Bit-Windows gibt Windows (32-bit) NT 10.00 oder zumindest tut es auf meinem PC genannt. Aber das ist nicht in der genannten docs .

ich gewinnen haben 7 64 Bit + Excel 2010 32 Bit. Die Registrierung ist HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Office \ 14.0 \ Registration {90140000-002A-0000-1000-0000000FF1CE}

Also das Bitness von OS sagen kann, nicht von Office Bitness

Ich habe eine sichere und zuverlässige Art und Weise in meinem InnoSetup-basierten Skript gefunden zu verstehen, ob eine bestimmte Anwendung ist 32-Bit oder 64-Bit (in meinem Fall musste ich Excel testen), indem Sie eine Win32-API-Funktion verwenden. Diese Funktion wird GetBinaryType() genannt, es kommt von `kernel32' (trotz des Namens es in 32 und 64 Bit Geschmack kommt) und schaut direkt in die EXE-Header.

Dieser Wikipedia-Artikel heißt es:

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

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

Eine weitere Möglichkeit, die Bitness von Office zu erkennen ist, die typelib herauszufinden.

Zum Beispiel Outlook Bitness 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önnten andere typelib id Office-Komponente herausfinden, und die erste Zeile der Funktion für sie ersetzen. Hier ist eine kurze Liste von 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 oben lib-ID durch das Windows SDK-Tool OLE-COM Object Viewer gefunden wurden, könnten Sie mehr lib-ID herausfinden, indem Sie es.

Der Vorteil dieses Ansatzes ist, dass es für alle Versionen von Büroarbeiten und ermöglicht die Steuerung auf jeder einzelne Komponente in ihrem Interesse. Darüber hinaus sind diese Schlüssel in HKEY_CLASSES_ROOT und tief in das System integriert, so ist es höchst unwahrscheinlich, dass sie nicht zugänglich, auch in einer Sandbox-Umgebung waren.

Hinweis GUT: Die detectVersion Funktion der oben aufgeführt ist funktioniert nicht . Ich habe eine 64-Bit-Version von Office, und einen weiteren mit 32 beiden Versionen mit dieser Funktion return „32-Bit“.

führt die Registrierung manuell prüfen zu dem gleichen Schluss:. Beide 64 und 32 Bit (Office 2010 x64 und Office 2013 32 Bit) berichten 32 Bit

Ich persönlich denke, das Office-Team sollte einfach schreiben und pflegen einen einfachen Registrierungsschlüssel irgendwo zu erhalten. All Add-in Bedürfnisse, dies zu verweisen, und zur Zeit „erraten“ ist ein schlechter Ansatz für Entwickler zu verwenden, gezwungen werden.

Sie müssen nicht an das Skript es. Schauen Sie sich diese Seite, die ich stolperte über:

https://social.msdn.microsoft.com/Forums/office/en-US/43499ae0-bcb5-4527- 8edb-f5a955987b56 / how-to-detect-ob-installed-ms-office-2010-is-32-oder 64-Bit? forum = worddev

Um es zusammenzufassen:

Das vierte Feld in dem Productcode zeigt die Bitness des Produkts.

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

0 für x86, 1 x 64 0-1 (Dies gilt für MS Office 2013 auch true)

Nach der Registrierung für den Installationspfad des Büros Komponente, die Sie interessiert sind, z.B. für Excel 2010 Blick in SOFTWARE (Wow6432Node) \ Microsoft \ Office \ 14.0 \ Excel \ InstallRoot. Es wird nur entweder in der 32-Bit-Registrierung oder die 64-Bit-Registrierung nicht beide.

Outlook Bitness Registrierungsschlüssel existiert nicht auf meinem Rechner.

Eine Möglichkeit, Outlook Bitness zu bestimmen, ist durch die Untersuchung Outlook.exe, selbst und bestimmen, ob es 32bit oder 64bit ist.

Im Einzelnen können Sie überprüfen die [IMAGE_FILE_HEADER.Machine] [1] geben, und dies wird ein Wert, der angibt Prozessortyp zurück.

Für einen ausgezeichneten Hintergrund dieser Diskussion auf den PE-Header einer Datei zu lesen lesen diese (veraltet Link) , in dem es heißt;

Die IMAGE_NT_HEADERS Struktur ist der primäre Ort, an dem Spezifika der PE-Datei gespeichert werden. Sein Offset wird durch das e_lfanew Feld in dem IMAGE_DOS_HEADER am Anfang der Datei angegeben. Tatsächlich gibt es zwei Versionen der IMAGE_NT_HEADER Struktur, ein für 32-Bit-Programme und die andere für 64-Bit-Versionen. Die Unterschiede sind so gering, dass ich sie prüfen würde das gleiche für die Zwecke dieser Diskussion. Die einzig richtige, Microsoft zugelassene Art und Weise zwischen den beiden Formaten zu unterscheiden, ist über den Wert des magischen Feldes in der IMAGE_OPTIONAL_HEADER (beschrieben in Kürze).

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 die c # -Code hier .

Das magische Feld zu Beginn der IMAGE_OPTIONAL_HEADER Struktur ist, 2 Byte-Offset bei 24 von Anfang an der _IMAGE_NT_HEADERS. Es hat Werte von 0x10B für 32-Bit- und 0x20B für 64-Bit.

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

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

C: \ Benutzer \ me> Assoc msg

msg = Outlook.File.msg.15

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

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

Best einfache Art und Weise: Setzen Sie das über Icon auf Ihrem Office 2016-Anwendung. Beispiel Excel

1) Öffnen Sie Excel -> Datei -> Optionen -> Band anpassen

2) Sie ‚ll 2 Scheiben sehen. Befehle auswählen und individualisieren Sie das Band

3) Wählen Sie aus Befehl, wählen Sie alle Befehle

4) Aus der resultierenden Liste markiert über (Excel)

5) Aus dem Menüband anpassen Schmerz, Markieren Sie alle Artikel (ex. View), wo Sie die Über-Symbol setzen wollen

6) Klicken Sie auf Neue Gruppe an der Unterseite

7) Klicken Sie auf die Schaltfläche Hinzufügen zwischen den beiden Fensterbereich befindet. DONE

Wenn Sie nun die Registerkarte Ansicht in Excel klicken und klicken Sie auf über Sie werden sehen, 32-Bit oder 64-Bit-

Ich habe einen viel einfacheren Weg gefunden. Mit Powershell können wir Excel als COM-Objekt einhängen.

$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 der Operating diese Weise anfordern, wir bekommen seltsame Ergebnisse, hier anschauen. PC3 ist mein.

Ich hoffe, das für euch funktioniert. Sorry für den Mangel an Code; meine Skripte sind meist funktional.

Bearbeiten : Vergessen Sie nicht, den Code hinzuzufügen Excel zu schließen, nachdem Sie die Daten fertig sind abruft.
Nach der Prüfung gestern diesen Code hatte ich jede Menge Öffnung Excel und ganz plötzlich abstürzt ..
wird dies sicherstellen, dass Sie Benutzer und Administratoren halten werden glücklich (:

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

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

fand ich heraus, dass es eine Lösung in C # ist - das Original finden Sie hier: https: / /blogs.msdn.microsoft.com/webdav_101/2016/07/26/sample-detecting-installed-outlook-and-its-bitness/

Ich änderte es ein bisschen für meine Bedürfnisse.

übergeben Sie einfach die richtige outlookPath zu 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;



    }

Wenn man will nur wissen, was Zahl Bit eine installierte Version von Office 2010 ist, dann in jeder Anwendung von Office 2010, klicken Sie auf Datei und dann auf Hilfe. Informationen über die Versionsnummer aufgelistet, und daneben, in Klammern, ist entweder (32-Bit) oder (64-Bit).

Öffnen Sie Outlook 2013> Datei> Office-Konto> Über Outlook> klicken Sie auf große "? Über Outlook" button> lesen Popup Beschreibung

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow