CODEWITHSUNDEEP
.net
Jonathan Allen
Jonathan Allen

Reputation: 70287

How do I determine if a .NET application is 32 or 64 bit?

I have a .NET application that was supposed to be compiled as a 32-bit only application. I suspect my build server isn't actually doing it.

How do I determine if a .NET application is actually set to run in 32-bit mode?

Upvotes: 54

Views: 42759

Answers (8)

Florian Winter
Florian Winter

Reputation: 5279

This is an update of the old accepted answer from 2010:

  1. Open Visual Studio.
  2. Go to "Tools" --> "Command Line" --> "Developer Command Prompt".
  3. Run corflags <path/to/your/exe_or_dll_file>.

The output of corflags has changed and now looks like this:

Version   : v4.0.30319
CLR Header: 2.5
PE        : PE32
CorFlags  : 0x3
ILONLY    : 1
32BITREQ  : 1
32BITPREF : 0
Signed    : 0

The line to look for is 32BITREQ, which means "32-bit required". It is set to 1 if you build with Any CPU but also link against a 32-bit native DLL. This means your DLL or EXE is effectively "32-bit (only)", e.g., it cannot run in a 64-bit IIS application pool.

If a DLL was built with platform x64 rather than Any CPU, then the output may look like this:

Version   : v4.0.30319
CLR Header: 2.5
PE        : PE32+
CorFlags  : 0x1
ILONLY    : 1
32BITREQ  : 0
32BITPREF : 0
Signed    : 0

The string PE+ indicates that the DLL was built for x64. With x86 or Any CPU, it is PE32.

Upvotes: 3

Jaco Pretorius
Jaco Pretorius

Reputation: 24840

If you're trying to check whether or not a running application is running in 32-bit or 64-bit mode, open task manager and check whether or not it has an asterisk (*32) next to the name of the process.

EDIT (imported from answer by manna): As of Win8.1, the "bittyness" of a process is listed in a separate detail column labelled Platform. (Right click on any column header to expose the select columns menu.)

If you have a compiled dll and you want to check if it's compiled for 32-bit or 64-bit mode, do the following (from a related question). I would think that you want you dll to be compiled for AnyCPU.

Open Visual Studio Command Prompt and type "corflags [your assembly]". You'll get something like this:

c:\Program Files (x86)\Microsoft Visual Studio 9.0\VC>corflags "C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.Data.dll"
    
Microsoft (R) .NET Framework CorFlags Conversion Tool. Version 3.5.21022.8 Copyright (c) Microsoft Corporation. All rights reserved.
    
Version : v2.0.50727
CLR Header: 2.5
PE : PE32
CorFlags : 24
ILONLY : 0
32BIT : 0
Signed : 1

You're looking at PE and 32BIT specifically.

AnyCpu:

PE: PE32 32BIT: 0

x86:

PE: PE32 32BIT: 1

x64:

PE: PE32+ 32BIT: 0

Upvotes: 58

Kevin McKelvin
Kevin McKelvin

Reputation: 3547

To do this at runtime...

You can evaluate IntPtr.Size. If IntPtr.Size == 4 then it's 32 bit (4 x 8). If IntPtr.Size == 8 then it's 64 bit (8 x 8)

Upvotes: 29

manna
manna

Reputation: 198

I was searching for the same information and I found that since Windows 8.1, there is no more asterisk.

You have a Task Manager details column named "Platform". Its content is "32 bits" or "64 bits".

Upvotes: 2

Lloyd
Lloyd

Reputation: 29668

I use the following code:

[DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool IsWow64Process(
    [In] IntPtr hProcess,
    [Out] out bool wow64Process
);

With:

public static bool IsProcess64(Process process)
{
    if ((Environment.OSVersion.Version.Major == 5 && Environment.OSVersion.Version.Minor >= 1) || Environment.OSVersion.Version.Major >= 6) {
        bool ret_val;

        try {
            if (!WindowsAPI.IsWow64Process(process.Handle,out ret_val)) ret_val = false;
        } catch {
            ret_val = false;
        }

        if (!ret_val && IntPtr.Size == 8) {
            return true;
        } else {
            return false;
        }
    } else {
        return false;
    }
}

You can pass Process.CurrentProcess or similar to this.

Upvotes: 4

Vinko Vrsalovic
Vinko Vrsalovic

Reputation: 340151

If you want to test an assembly non programmatically, you can use corflags.exe

>corflags.exe <assembly>

<listing of header information, among them the 32bit-ness>

Upvotes: 2

x0n
x0n

Reputation: 52410

The quickest way is probably that it'll have an asterisk (*) after its name in task manager when run on a 64 bit machine. The asterisk means it's running in syswow64, ergo it's marked 32 bit.

The other way is to run corflags.exe against it and this will display the answer you're after. This comes with the .NET SDK.

Upvotes: 7

Dan Tao
Dan Tao

Reputation: 128317

Well, if you're using .NET 4.0, there's System.Environment.Is64BitProcess.

Upvotes: 12

Related Questions