ansaurus

Question

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

Answer 1

A:

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

Dan Tao 2010-09-23 20:14:16

I don't think this is answering the OP's question.

Will A 2010-09-23 20:14:47

Isn't there some flag in the assembly that says whether to JIT it into 32, 64 or either?

Steven Sudit 2010-09-23 20:14:55

@Will A: Couldn't the OP put that code in his app and cause it to display a message on loadup (or something)? It's an honest question -- I really thought this was what he wanted. Now that I see some of the other answers I realize maybe he wanted something outside the process itself, though.

Dan Tao 2010-09-23 20:19:02

@Dan - fair point, Task Manager would be an easier means of determining, however, this does of course work - sorry Dan!

Will A 2010-09-23 20:25:52

At runtime, doesn't checking `sizeof(IntPtr)` do it? (And, yes, I know that doesn't answer the OP's question, but it is relevant to Dan's answer.)

Jim Mischel 2010-09-23 20:41:35

@Jim: I don't think `sizeof(IntPtr)` is legal.

Dan Tao 2010-09-23 21:01:08

@Jim: I was wrong: looks like it's only legal in an `unsafe` context, though.

Dan Tao 2010-09-23 21:02:53

@Dan: You're right. I meant `IntPtr.Size`.

Jim Mischel 2010-09-23 21:51:04

Answer 2

+5 A:

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.

x0n 2010-09-23 20:15:08

Agreed, Task manager is *always* accurate. Corflags only shows intent.

Hans Passant 2010-09-23 20:18:57

Answer 3

+1 A:

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>

Vinko Vrsalovic 2010-09-23 20:15:27

Answer 4

+5 A:

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.

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"

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

Jaco Pretorius 2010-09-23 20:16:14

Thanks, that is exactly what I wanted. (Though your answer also pisses me off a bit because I knew CorFlags could change the setting, but nothing in the docs tells me that it can also read it.)

Jonathan Allen 2010-09-23 20:44:13

Answer 5

+3 A:

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.

Lloyd 2010-09-23 20:16:29

This has some flaws, mostly related to exceptionhandling: the "catch-all-and-everything" clause will also catch things like OutOfMemoryException, ThreadAbortException, AccessViolationException, etc. all stuff that signals a bad state of the CLR and has nothing to do with the process in question not beeing a 32bit process on 64 bit system (WOW64). Then, the "Handle" property throws an exception if called for process with no permission or which is gone already - it could still be 32bit process. Finally, if IntPtr.Size is 64, the process is 64 bit - no more need for the other stuff to check then.

Christian.K 2010-09-24 06:23:05

That is true I haven't changed this code in a long time. I should address all of those issues really.

Lloyd 2010-09-24 08:18:47

Answer 6

A:

Here's an article from MSDN that get's into this kind of question towards the bottom.

Andy Evans 2010-09-23 20:20:00

Answer 7

A:

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)

Kevin McKelvin 2010-09-23 21:11:21

That sounds like runtime, not design time.

Steven Sudit 2010-09-23 22:15:40

whoops, my bad. fixed :)

Kevin McKelvin 2010-09-23 22:31:42

ansaurus

tags:

views:

answers:

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

related questions