Как узнать разрядность word

From TechNet article on 64-bit editions of Office 2010:

If you have installed Office 2010
including Microsoft Outlook 2010,
Outlook sets a registry key named
Bitness of type REG_SZ on the computer on which it is installed. The
Bitness registry key indicates whether the Outlook 2010 installation
is 32-bit or 64-bit. This may be
useful to administrators who are
interested in auditing computers to
determine the installed versions of
Office 2010 in their organization.

• Registry path: HKEY_LOCAL_MACHINESoftwareMicrosoftOffice14.0Outlook
• if you have installed Office 2013 then use this
  Registry path: HKEY_LOCAL_MACHINESoftwareMicrosoftOffice15.0Outlook
• Registry key: Bitness
• Value: either x86 or x64

and elsewhere in the same article:

Starting with Office 2010, Outlook is
available as a 32-bit application and
a 64-bit application. The version
(bitness) of Outlook that you choose
depends on the edition of the Windows
operating system (32-bit or 64-bit)
and the edition of Office 2010 (32- or
64-bit) that is installed on the
computer, if Office is already
installed on that computer.

Factors that determine the feasibility
of installing a 32-bit or a 64-bit
version of Outlook include the
following:

• You can install 32-bit Office 2010 and 32-bit Microsoft Outlook 2010 on a supported 32-bit or 64-bit edition of the Windows operating system. You can install the 64-bit version of Office 2010 and 64-bit Outlook 2010 only on a supported 64-bit operating system.
• The default installation of Office 2010 on a 64-bit edition of the Windows operating system is 32-bit Office 2010.
• The bitness of an installed version of Outlook is always the same as the bitness of Office 2010, if Office is installed on the same computer. That is, a 32-bit version of Outlook 2010 cannot be installed on the same computer on which 64-bit versions of other Office 2010 applications are already installed, such as 64-bit Microsoft Word 2010 or 64-bit Microsoft Excel 2010. Similarly, a 64-bit version of Outlook 2010 cannot be installed on the same computer on which 32-bit versions of other Office applications are already installed.

To add to vtrz’s answer, here’s a function I wrote for 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,
      'SOFTWAREMicrosoftWindowsCurrentVersionApp Pathsexcel.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;

Regret to say, but Both Otacku’s and @clatonh’s methods aren’t working for me — neither have Outlook Bitness nor {90140000-0011-0000-1000-0000000FF1CE} in registry (for 64-bit Office without Outlook installed).

The only way I have found, though, not via the registry, is to check bitness for one of the Office executables with the use of the Windows API function GetBinaryType (since Windows 2000 Professional).

For example, you can check the bitness of Winword.exe, which path is stored under
HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionApp PathsWinword.exe.

Here is the MFC code fragment:

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
}

answered Apr 27, 2011 at 14:56

I found the way for checking office bitness .

We can check office 365 and 2016 bitness using this registry key:

HKEY_LOCAL_MACHINESOFTWAREMicrosoftOfficeClickToRunConfiguration

Platform x86 for 32 bit.

HKEY_LOCAL_MACHINESOFTWAREMicrosoftOfficeClickToRunConfiguration

Platform x64 for 64 bit.

Please check…

Attention: querying the bitness of the Outlook Application does NOT reliably work if called in .NET environment.

Here, we use GetBinaryType() in a DLL that can be called by any application:

• If the host application is 64 bit C/C++, GetBinaryType() returns SCS_32BIT_BINARY.
• If the host application is 64 bit .NET (we tested «AnyCPU» on a 64 bit system), GetBinaryType() returns SCS_64BIT_BINARY.

With exactly the same DLL code and exactly the same Outlook binary path («c:/Program Files (x86)/…») on the same computer.

Meaning that you might need to test the binary file yourself using «IMAGE_NT_HEADERS.FileHeader.Machine» entry.

God, I hate the incorrect return values of some Windows APIs (see also GetVersion() lie).

answered Mar 26, 2014 at 8:17

I found this approach:

If HKLMSoftwareWOW6432Node exists then Windows is 64-bit.

If HKLMSoftwareWOW6432NodeMicrosoftOffice exists, then Office is 32-bit.

If HKLMSoftwareWOW6432NodeMicrosoftOffice does not exist, but HKLMSoftwareMicrosoftOffice does exist, then Office is 64-bit.

If HKLMSoftwareWOW6432Node does not exist, then Windows and Office are 32-bit.

Source: Technet Forums

answered Apr 4, 2012 at 18:33

You can search the registry for {90140000-0011-0000-0000-0000000FF1CE}. If the bold numbers start with 0 its x86, 1 is x64

For me it was in
HKEY_LOCAL_MACHINESOFTWAREMicrosoftOffice14.0Registration{90140000-0057-0000-0000-0000000FF1CE}

Source

Not via the registry but via commandline tools:

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

C:Usersme>assoc .msg

.msg=Outlook.File.msg.15

C:Usersme>ftype Outlook.File.msg.15

Outlook.File.msg.15=»C:Program Files (x86)Microsoft OfficeRootOffice16OUTLOOK.EXE» /f «%1»

EDIT : Solution without touching RegistryKeys — im Sorry Op.

I found out that there is a solution in C# — the original can be found here :
https://blogs.msdn.microsoft.com/webdav_101/2016/07/26/sample-detecting-installed-outlook-and-its-bitness/

I modified it a bit for my needs.

just pass the correct outlookPath to 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;



    }

answered Apr 29, 2019 at 16:12

answered Aug 16, 2010 at 11:47

Jon BrightJon Bright

13.3k3 gold badges30 silver badges46 bronze badges

toosensitivetoosensitive

2,2957 gold badges46 silver badges88 bronze badges

answered Jun 14, 2012 at 13:08

This Wikipedia article states:

On 64-bit versions of Windows, there are two folders for application files; the "Program Files" folder contains 64-bit programs, and the "Program Files (x86)" folder contains 32-bit programs.

So if the program is installed under C:Program Files it is a 64-bit version. If it is installed under C:Program Files (x86) it is a 32-bit installation.

Another way to detect the bitness of Office is to find out the typelib.

For example, to detect Outlook’s bitness, write a .JS file as following:

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

You could find out other Office component’s typelib id, and replace the first line of the function for it. Here is a brief list of interesting 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

All above lib id were found through the Windows SDK tool OLE-COM Object Viewer, you could find out more lib id’s by using it.

The benefit of this approach is that it works for all versions of office, and provides control on every single component in you interest. Furthermore, those keys are in the HKEY_CLASSES_ROOT and deeply integrated into the system, so it is highly unlikely they were not accessible even in a sandbox environment.

answered Apr 24, 2013 at 0:26

Outlook Bitness registry key does not exist on my machine.

One way to determine Outlook Bitness is by examining Outlook.exe, itself and determine if it is 32bit or 64bit.

Specifically, you can check the [IMAGE_FILE_HEADER.Machine][1] type and this will return a value indicating processor type.

For an excellent background of this discussion, on reading the PE Header of a file read this (outdated link), which states;

The IMAGE_NT_HEADERS structure is the primary location where specifics of the PE file are stored. Its offset is given by the e_lfanew field in the IMAGE_DOS_HEADER at the beginning of the file. There are actually two versions of the IMAGE_NT_HEADER structure, one for 32-bit executables and the other for 64-bit versions. The differences are so minor that I’ll consider them to be the same for the purposes of this discussion. The only correct, Microsoft-approved way of differentiating between the two formats is via the value of the Magic field in the IMAGE_OPTIONAL_HEADER (described shortly).

An IMAGE_NT_HEADER is comprised of three fields:

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


and you can get the c# code here.

The Magic field is at the start of the IMAGE_OPTIONAL_HEADER structure, 2 bytes at offset 24 from the start of the _IMAGE_NT_HEADERS. It has values of 0x10B for 32-bit and 0x20B for 64-bit.

I’ve found a much easier way.
Using Powershell, we can hook Excel as a COM object.

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

When requesting the OperatingSystem this way, we get strange results,
have a look here. PC3 is mine.

I hope this works for you guys. Sorry for the lack of code; my scripts are mostly functional.

Edit:
Don’t forget to add the code to close Excel after you’re done retrieving the data.
After testing this code yesterday I had tons of Excel opening and crashing all of a sudden..
This will make sure you’ll keep users and admins happy (:

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

answered Aug 15, 2017 at 8:29

answered Jul 29, 2012 at 5:22