How to Tell If My Application Is Running as a 32-Bit or 64-Bit Application

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

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

How do I tell if my application is running as a 32-bit or 64-bit application?

if (IntPtr.Size == 8) 
{
    // 64 bit machine
} 
else if (IntPtr.Size == 4) 
{
    // 32 bit machine
}

Check if my program is running in 32 bit mode on a 64bit machine, if running in 64bit - how do I force it to be 32bit

One plausible explanation for the discrepency is that you're deploying the output of a different build configuration.

Could it be that you setup your Debug configuration to target x86, but didn't make the change to the Release configuration, thereby leaving it as AnyCPU and deploying it to production?

How to determine programmatically whether a particular process is 32-bit or 64-bit

One of the more interesting ways I've seen is this:

if (IntPtr.Size == 4)
{
    // 32-bit
}
else if (IntPtr.Size == 8)
{
    // 64-bit
}
else
{
    // The future is now!
}

To find out if OTHER processes are running in the 64-bit emulator (WOW64), use this code:

namespace Is64Bit
{
    using System;
    using System.ComponentModel;
    using System.Diagnostics;
    using System.Runtime.InteropServices;

    internal static class Program
    {
        private static void Main()
        {
            foreach (var p in Process.GetProcesses())
            {
                try
                {
                    Console.WriteLine(p.ProcessName + " is " + (p.IsWin64Emulator() ? string.Empty : "not ") + "32-bit");
                }
                catch (Win32Exception ex)
                {
                    if (ex.NativeErrorCode != 0x00000005)
                    {
                        throw;
                    }
                }
            }

            Console.ReadLine();
        }

        private static bool IsWin64Emulator(this Process process)
        {
            if ((Environment.OSVersion.Version.Major > 5)
                || ((Environment.OSVersion.Version.Major == 5) && (Environment.OSVersion.Version.Minor >= 1)))
            {
                bool retVal;

                return NativeMethods.IsWow64Process(process.Handle, out retVal) && retVal;
            }

            return false; // not on 64-bit Windows Emulator
        }
    }

    internal static class NativeMethods
    {
        [DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)]
        [return: MarshalAs(UnmanagedType.Bool)]
        internal static extern bool IsWow64Process([In] IntPtr process, [Out] out bool wow64Process);
    }
}

Delphi: How to determine if an application is running under Win32 / Win64 and launch the 64-bit version automatically if on 64-bit?

Launching other executable

First, we need a function capable of launching other executable file, my very generic example follows, you can use it for launching almost any other executable depending on your demands:

function LaunchExecutableFile(const ExecutableFilePath, Parameters: string; const ShowCmd: Integer): Boolean;
begin
  Result := Winapi.ShellAPI.ShellExecute(Application.MainFormHandle, 'open', PChar(StringFunctions.DoubleQuoteStr(ExecutableFilePath)), PChar(Parameters), nil, ShowCmd) > 32;
end;

Notes:

I intentionally added the optional namespaces like Winapi.ShellAPI... in order for you to know exactly where those functions are defined.
There are 32 error codes defined, that is why the function returns True if the result of ShellExecute was greater than 32.
I defined function DoubleQuoteStr, because if there are some spaces in the path, the system would otherwise look for the file in each space delimited and therefore wrong path. It's a very simple function, and it is completely optional, it is just optimization. This, also generic, function follows:
```
function DoubleQuoteStr(S: string): string;
begin
  if (S = '') or (S = '"')
    then S := '""'
    else begin
      if S[1] <> '"' then S := '"' + S;
      if S[System.Length(S)] <> '"' then S := S + '"';
    end;
  Result := S;
end;
```
Sadly, I am still unsure about the first ShellExecute HWND argument, more specifically if my generic way is right, feel free to correct me!

Detecting 64-bit system

Second, we need a function capable of detecting 64-bit system, more specifically, if the executable is running under WOW64.

function IsWow64Process: Boolean;

type
  TIsWow64Process = function(AHandle: DWORD; var AIsWow64: BOOL): BOOL; stdcall;

var
  hIsWow64Process: TIsWow64Process;
  hKernel32: DWORD;
  IsWow64: BOOL;

begin
  Result := False;

  hKernel32 := Winapi.Windows.LoadLibrary('kernel32.dll');
  if hKernel32 = 0 then Exit;

  try
    @hIsWow64Process := Winapi.Windows.GetProcAddress(hKernel32, 'IsWow64Process');
    if not System.Assigned(hIsWow64Process) then Exit;

    IsWow64 := False;
    if hIsWow64Process(Winapi.Windows.GetCurrentProcess, IsWow64) then
      Result := IsWow64;

  finally
    Winapi.Windows.FreeLibrary(hKernel32);
  end;
end;

Notes:

As you can see, the function loads library kernel32.dll and function IsWow64Process from it.
Every safety measure should be in place as for the correct result to be returned.

Running the program

Finally, we need to adjust our dpr file.

To the variables section, add:

var
{$IFNDEF WIN64}
  App64: string;
{$ENDIF}

Enclose your main begin - end section into another begin - end.

And add something like this at the beginning:

{$IFNDEF WIN64}

  App64 := System.SysUtils.ChangeFileExt(Application.ExeName, '64.exe');

  if not (ProcessFunctions.IsWow64Process and System.SysUtils.FileExists(App64) and
          ProcessFunctions.LaunchExecutableFile(App64, '', SW_SHOWNORMAL)) then

{$ENDIF}

How can my program determine if it is running on 32-bit or 64-bit Windows?

How to detect Windows 64 bit platform with .net? might be helpful.

How to tell if app is running in 32-bit or 64-bit mode?

Here are some of the ways :
http://rongchaua.net/blog/c-how-to-determine-processor-64-bit-or-32-bit/

how to check whether services is running on 32 or 64 bit mode

You can check the task manager, 32 bit processes have *32 appended to their name in the processes list.

How to tell whether my ASP.NET app is 32bit in a 32bit IIS worker process

You already answered your own question, looking at:

Environment.Is64BitProcess

is good enough.

Applications on IIS are hosted in worker processes, each worker process can either be 32 or 64bit. This is a setting on the application pool that corresponds to the process. So all apps in the process have the same bitness. Your app always uses the same bitness as it application pool worker process.