Identifying the CPU architecture type using C#

Question

I want to check which CPU architecture is the user running, is it i386 or X64 or AMD64. I want to do it in C#. I know i can try WMI or Registry. Is there any other way apart from these two? My project targets .NET 2.0!

Answer 1

You could also try (only works if it's not manipulated):

System.Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE")

Answer 2

Finally the shortest trick to resolve the platform/processor architecture for the current running CLR runtime in C# is:

PortableExecutableKinds peKind;
ImageFileMachine machine;
typeof(object).Module.GetPEKind(out peKind, out machine);

Here Module.GetPEKind returns an ImageFileMachine enumeration, which exists since .NET v2:

public enum ImageFileMachine
{
    I386    = 0x014C,
    IA64    = 0x0200,
    AMD64   = 0x8664,
    ARM     = 0x01C4    // new in .NET 4.5
}

Why not use new AssemblyName(fullName) or typeof(object).Assembly.GetName()?
Well there is this HACK comment in ASP.NET MVC source code (since 1.0):

private static string GetMvcVersionString() {
    // DevDiv 216459:
    // This code originally used Assembly.GetName(), but that requires FileIOPermission, which isn't granted in
    // medium trust. However, Assembly.FullName *is* accessible in medium trust.
    return new AssemblyName(typeof(MvcHttpHandler).Assembly.FullName).Version.ToString(2);
}

See they use some hidden tricks for themselves. Sadly, the AssemblyName constructor doesn't set the ProcessorArchitecture field appropriately, it's just None for whatever new AssemblyName.

So for future readers, let me recommend you using that ugly GetPEKind with ImageFileMachine!

Notes:

• This returns the current running runtime architecture, not the underlying system architecture!
  That said, the only exception is that an I386 runtime may run on an AMD64 system.
• Tested on mono/ubuntu 14.04/AMD64 and .NET/Win7/I386.

Answer 3

Depending on why you want to know, you might find that checking the size of the IntPtr structure is the easiest way.

Answer 4

Win32_Processor WMI Class will do the job. Use MgmtClassGen.exe to generate strongly-typed wrappers.

Answer 5

Here is a piece of code that seems to work (based on P/Invoke):

    public static ProcessorArchitecture GetProcessorArchitecture()
    {
        SYSTEM_INFO si = new SYSTEM_INFO();
        GetNativeSystemInfo(ref si);
        switch (si.wProcessorArchitecture)
        {
            case PROCESSOR_ARCHITECTURE_AMD64:
                return ProcessorArchitecture.Amd64;

            case PROCESSOR_ARCHITECTURE_IA64:
                return ProcessorArchitecture.IA64;

            case PROCESSOR_ARCHITECTURE_INTEL:
                return ProcessorArchitecture.X86;

            default:
                return ProcessorArchitecture.None; // that's weird :-)
        }
    }

with

    [DllImport("kernel32.dll")]
    private static extern void GetNativeSystemInfo(ref SYSTEM_INFO lpSystemInfo);

    private const int PROCESSOR_ARCHITECTURE_AMD64 = 9;
    private const int PROCESSOR_ARCHITECTURE_IA64 = 6;
    private const int PROCESSOR_ARCHITECTURE_INTEL = 0;

    [StructLayout(LayoutKind.Sequential)]
    private struct SYSTEM_INFO
    {
        public short wProcessorArchitecture;
        public short wReserved;
        public int dwPageSize;
        public IntPtr lpMinimumApplicationAddress;
        public IntPtr lpMaximumApplicationAddress;
        public IntPtr dwActiveProcessorMask;
        public int dwNumberOfProcessors;
        public int dwProcessorType;
        public int dwAllocationGranularity;
        public short wProcessorLevel;
        public short wProcessorRevision;
    }

Note this code reuses the existing CLR's ProcessorArchitecture enum, and supports .NET framework 2 and higher.

Answer 6

What led me here is checking for a 32 vs 64 bit OS. the highest rated answer is looking at the setting for the Current process. After not finding an answer I found the following setting. Hope this works for you.

bool is64 = System.Environment.Is64BitOperatingSystem