使用 C# 识别 CPU 架构类型

Question

我想检查用户运行的是哪个CPU架构，是吗 i386 或 X64 或 AMD64。 我想用 C# 来做。 我知道我可以尝试 WMI 或注册表。 除了这两种还有其他办法吗？ 我的项目目标是.NET 2.0！

Answer 1

我知道这个问题是过去的问题，但截至 2017 年，现在有一个简单的方法可以了解当前进程的体系结构，在 .net 标准中：

System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture

返回的值是 X86、X64、ARM、ARM64 之一，并给出它正在运行的进程的体系结构。OSArchitecture 返回已安装操作系统的体系结构。

文档链接（虽然没什么用......）：

RuntimeInformation.ProcessArchitecture：
https://learn .microsoft.com/en-us/dotnet/api/system.runtime.interopservices.runtimeinformation.processarchitecture?view=netstandard-1.4

架构枚举：
https://learn.microsoft .com/en-us/dotnet/api/system.runtime.interopservices.architecture?view=netstandard-1.4

Answer 2

您也可以尝试（仅在不被操纵的情况下有效）：

System.Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE")

Answer 3

让我来到这里的是检查 32 位与 64 位操作系统。 评分最高的答案是查看当前进程的设置。 在找不到答案后，我找到了以下设置。 希望这对你有用。

bool is64 = System.Environment.Is64BitOperatingSystem

Answer 4

这是一段似乎可以工作的代码（基于 P/Invoke）； 它允许确定 CPU/机器架构、当前进程架构以及给定的二进制文件架构（如何编译）：

    public enum Architecture
    {
        Unknown,
        x86,
        x64,
        arm64,
    }

    public static Architecture ProcessArchitecture
    {
        get
        {
            var si = new SYSTEM_INFO();
            GetSystemInfo(ref si);
            return GetArchitecture(ref si);
        }
    }

    public static Architecture MachineArchitecture
    {
        get
        {
            var si = new SYSTEM_INFO();
            GetNativeSystemInfo(ref si);
            return GetArchitecture(ref si);
        }
    }

    public static Architecture ReadFileArchitecture(string filePath)
    {
        if (filePath == null)
            throw new ArgumentNullException(nameof(filePath));

        using (var stream = File.OpenRead(filePath))
        {
            return ReadFileArchitecture(stream);
        }
    }

    // note .NET dll will come out as x86
    public static Architecture ReadFileArchitecture(Stream stream)
    {
        if (stream == null)
            throw new ArgumentNullException(nameof(stream));

        var length = stream.Length;
        if (length < 64)
            return Architecture.Unknown;

        var reader = new BinaryReader(stream);
        stream.Position = 60;
        var peHeaderPtr = reader.ReadUInt32();
        if (peHeaderPtr == 0)
        {
            peHeaderPtr = 128;
        }
        if (peHeaderPtr > length - 256)
            return Architecture.Unknown;

        stream.Position = peHeaderPtr;
        var peSignature = reader.ReadUInt32();
        if (peSignature != 0x00004550) // "PE"
            return Architecture.Unknown;

        var machine = reader.ReadUInt16();
        Architecture arch;
        switch (machine)
        {
            case IMAGE_FILE_MACHINE_AMD64:
                arch = Architecture.x64;
                break;

            case IMAGE_FILE_MACHINE_I386:
                arch = Architecture.x86;
                break;

            case IMAGE_FILE_MACHINE_ARM64:
                arch = Architecture.arm64;
                break;

            default:
                return Architecture.Unknown;
        }
        return arch;
    }

    private static Architecture GetArchitecture(ref SYSTEM_INFO si)
    {
        switch (si.wProcessorArchitecture)
        {
            case PROCESSOR_ARCHITECTURE_AMD64:
                return Architecture.x64;

            case PROCESSOR_ARCHITECTURE_ARM64:
                return Architecture.arm64;

            case PROCESSOR_ARCHITECTURE_INTEL:
                return Architecture.x86;

            default:
                throw new PlatformNotSupportedException();
        }
    }

    private const int PROCESSOR_ARCHITECTURE_AMD64 = 9;
    private const int PROCESSOR_ARCHITECTURE_INTEL = 0;
    private const int PROCESSOR_ARCHITECTURE_ARM64 = 12;
    private const int IMAGE_FILE_MACHINE_ARM64 = 0xAA64;
    private const int IMAGE_FILE_MACHINE_I386 = 0x14C;
    private const int IMAGE_FILE_MACHINE_AMD64 = 0x8664;

    [DllImport("kernel32")]
    private static extern void GetSystemInfo(ref SYSTEM_INFO lpSystemInfo);

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

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

此代码支持 x86、x64 和 arm64 架构以及 Windows XP。 在现代版本的 .NET 中，您在 System.Runtime.InteropServices.RuntimeInformation 命名空间。

Answer 5

Win32_Processor WMI 类将完成这项工作。 使用 MgmtClassGen.exe 生成强类型包装器。

Answer 6

最后，解决 C# 中当前运行的 CLR 运行时的平台/处理器体系结构的最短技巧是：

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

这里 Module.GetPEKind 返回 ImageFileMachine 枚举，自 .NET v2 以来就存在：

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

为什么不使用 new AssemblyName(fullName) 或 <代码>typeof(object).Assembly.GetName()？
ASP.NET MVC 源代码（自 1.0 起）中有这样的 HACK 注释：

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

看看他们为自己使用了一些隐藏的技巧。 遗憾的是，AssemblyName 构造函数没有正确设置 ProcessorArchitecture 字段，对于任何新的 AssemblyName，它只是 None。

因此，对于未来的读者，我建议您使用丑陋的 GetPEKind 和 ImageFileMachine！

注意：

• 这将返回当前正在运行的运行时架构，而不是底层系统架构！
  也就是说，唯一的例外是 I386 运行时可以在 AMD64 系统上运行。
• 在 mono/ubuntu 14.04/AMD64 和 .NET/Win7/I386 上测试。

Answer 7

这个怎么样？

switch (typeof(string).Assembly.GetName().ProcessorArchitecture) {
    case System.Reflection.ProcessorArchitecture.X86:
        // '$(Platform)' == 'x86'
        break;
    case System.Reflection.ProcessorArchitecture.Amd64:
        // '$(Platform)' == 'x64'
        break;
    case System.Reflection.ProcessorArchitecture.MSIL:
        // MacBook Pro with M1 Pro (from comment)
        // Linux aarch64 (net60; AWS Graviton2)
        // Windows 11 Pro (net60; Arm64-based Azure VM)
        break;
    case System.Reflection.ProcessorArchitecture.None:
        // ASP.NET Core Blazor WebAssembly (net60)
        break;
    case System.Reflection.ProcessorArchitecture.Arm:
        // Unknown
        break;
}

但是 case *.Arm: 尚未测试。

Answer 8

也许这篇 CodeProject 文章会有所帮助？ 它使用 System.Management 命名空间中的 ManagementObjectSearcher 来搜索硬件信息。

Answer 9

根据您想知道的原因，您可能会发现检查 IntPtr 结构的大小是最简单的方法。

Answer 10

你也许可以问问用户？

当然只是开玩笑...我认为 WMI 就是您所使用的。 但也许还有其他方法呢？

如果您选择 WMI，那么 LinqToWmi 可能会有用。 我尝试过一次，看起来非常简单 =) -> http://www.codeplex.com/linq2wmi

Answer 11

这对我来说似乎是最简单的：

System.Environment.Is64BitOperatingSystem

Answer 12

这是我的方法：

如果操作系统是 Linux，则调用 libc-syscall uname，您将在 Machine 字段中看到处理器。

如果操作系统是Windows，检查System.IntPtr.Size * 8 = 64，则它是64位。
如果不是 64 位，则检查 IsWow64Process 是否存在，如果存在，并且进程是 Wow64，则它是 x86-64，否则它是 x86-32。

这个是可靠的。
检查处理器架构环境变量则不然。

代码：

namespace RamMonitorPrototype
{


    // https://stackoverflow.com/a/55202696/155077
    //[System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential)]
    //unsafe internal struct Utsname_internal
    //{
    //    public fixed byte sysname[65];
    //    public fixed byte nodename[65];
    //    public fixed byte release[65];
    //    public fixed byte version[65];
    //    public fixed byte machine[65];
    //    public fixed byte domainname[65];
    //}


    public class Utsname
    {
        public string SysName; // char[65]
        public string NodeName; // char[65]
        public string Release; // char[65]
        public string Version; // char[65]
        public string Machine; // char[65]
        public string DomainName; // char[65]

        public void Print()
        {
            System.Console.Write("SysName:\t");
            System.Console.WriteLine(this.SysName); // Linux 

            System.Console.Write("NodeName:\t");
            System.Console.WriteLine(this.NodeName); // System.Environment.MachineName

            System.Console.Write("Release:\t");
            System.Console.WriteLine(this.Release); // Kernel-version

            System.Console.Write("Version:\t");
            System.Console.WriteLine(this.Version); // #40~18.04.1-Ubuntu SMP Thu Nov 14 12:06:39 UTC 2019

            System.Console.Write("Machine:\t");
            System.Console.WriteLine(this.Machine); // x86_64

            System.Console.Write("DomainName:\t");
            System.Console.WriteLine(this.DomainName); // (none)
        }


    }


    // https://github.com/microsoft/referencesource/blob/master/System/compmod/microsoft/win32/UnsafeNativeMethods.cs
    // https://github.com/dotnet/corefx/blob/master/src/Common/src/CoreLib/System/Environment.Windows.cs
    public class DetermineOsBitness
    {
        private const string Kernel32 = "kernel32.dll";



        [System.Runtime.InteropServices.DllImport("libc", EntryPoint = "uname", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl)]
        private static extern int uname_syscall(System.IntPtr buf);

        // https://github.com/jpobst/Pinta/blob/master/Pinta.Core/Managers/SystemManager.cs
        public static Utsname Uname()
        {
            Utsname uts = null;
            System.IntPtr buf = System.IntPtr.Zero;

            buf = System.Runtime.InteropServices.Marshal.AllocHGlobal(8192);
            // This is a hacktastic way of getting sysname from uname ()
            if (uname_syscall(buf) == 0)
            {
                uts = new Utsname();
                uts.SysName = System.Runtime.InteropServices.Marshal.PtrToStringAnsi(buf);

                long bufVal = buf.ToInt64();
                uts.NodeName = System.Runtime.InteropServices.Marshal.PtrToStringAnsi(new System.IntPtr(bufVal + 1 * 65));
                uts.Release = System.Runtime.InteropServices.Marshal.PtrToStringAnsi(new System.IntPtr(bufVal + 2 * 65));
                uts.Version = System.Runtime.InteropServices.Marshal.PtrToStringAnsi(new System.IntPtr(bufVal + 3 * 65));
                uts.Machine = System.Runtime.InteropServices.Marshal.PtrToStringAnsi(new System.IntPtr(bufVal + 4 * 65));
                uts.DomainName = System.Runtime.InteropServices.Marshal.PtrToStringAnsi(new System.IntPtr(bufVal + 5 * 65));

                if (buf != System.IntPtr.Zero)
                    System.Runtime.InteropServices.Marshal.FreeHGlobal(buf);
            } // End if (uname_syscall(buf) == 0) 

            return uts;
        } // End Function Uname



        [System.Runtime.InteropServices.DllImport(Kernel32, CharSet = System.Runtime.InteropServices.CharSet.Auto, BestFitMapping = false)]
        [System.Runtime.Versioning.ResourceExposure(System.Runtime.Versioning.ResourceScope.Machine)]
        private static extern System.IntPtr GetModuleHandle(string modName);


        [System.Runtime.InteropServices.DllImport(Kernel32, CharSet = System.Runtime.InteropServices.CharSet.Ansi, BestFitMapping = false, SetLastError = true, ExactSpelling = true)]
        [System.Runtime.Versioning.ResourceExposure(System.Runtime.Versioning.ResourceScope.None)]
        private static extern System.IntPtr GetProcAddress(System.IntPtr hModule, string methodName);


        [System.Runtime.InteropServices.DllImport(Kernel32, SetLastError = true, CallingConvention = System.Runtime.InteropServices.CallingConvention.Winapi)]
        [return: System.Runtime.InteropServices.MarshalAs(System.Runtime.InteropServices.UnmanagedType.Bool)]
        private static extern bool IsWow64Process(
             [System.Runtime.InteropServices.In] Microsoft.Win32.SafeHandles.SafeHandleZeroOrMinusOneIsInvalid hProcess,
             [System.Runtime.InteropServices.Out, System.Runtime.InteropServices.MarshalAs(System.Runtime.InteropServices.UnmanagedType.Bool)] out bool wow64Process
        );


        [System.Security.SecurityCritical]
        private static bool DoesWin32MethodExist(string moduleName, string methodName)
        {
            System.IntPtr hModule = GetModuleHandle(moduleName);

            if (hModule == System.IntPtr.Zero)
            {
                System.Diagnostics.Debug.Assert(hModule != System.IntPtr.Zero, "GetModuleHandle failed.  Dll isn't loaded?");
                return false;
            }

            System.IntPtr functionPointer = GetProcAddress(hModule, methodName);
            return (functionPointer != System.IntPtr.Zero);
        }

        public static bool Is64BitOperatingSystem()
        {
            if (System.IntPtr.Size * 8 == 64)
                return true;

            if (!DoesWin32MethodExist(Kernel32, "IsWow64Process"))
                return false;

            bool isWow64;

            using(Microsoft.Win32.SafeHandles.SafeWaitHandle safeHandle = new Microsoft.Win32.SafeHandles.SafeWaitHandle(System.Diagnostics.Process.GetCurrentProcess().Handle, true))
            {
                IsWow64Process(safeHandle, out isWow64);
            }
            return isWow64;
        }

        // This doesn't work reliably
        public static string GetProcessorArchitecture()
        {
            string strProcessorArchitecture = null;

            try
            {
                strProcessorArchitecture = System.Convert.ToString(System.Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE"));

                switch (typeof(string).Assembly.GetName().ProcessorArchitecture)
                {
                    case System.Reflection.ProcessorArchitecture.X86:
                        strProcessorArchitecture = "x86";
                        break;
                    case System.Reflection.ProcessorArchitecture.Amd64:
                        strProcessorArchitecture = "x86";
                        break;
                    case System.Reflection.ProcessorArchitecture.Arm:
                        strProcessorArchitecture = "ARM";
                        break;
                }

                bool is64bit = !string.IsNullOrEmpty(System.Environment.GetEnvironmentVariable("PROCESSOR_ARCHITEW6432"));

                if (is64bit)
                    strProcessorArchitecture += "-64";
                else
                    strProcessorArchitecture += "-32";
            }
            catch (System.Exception ex)
            {
                strProcessorArchitecture = ex.Message;
            }

            return strProcessorArchitecture;
        } // End Function GetProcessorArchitecture


    }


}

Answer 13

我使用了这个：Environment.Is64BitOperatingSystem

例如：Environment.Is64BitOperatingSystem ？ "win-x64" : "win-x86"

它适用于 .NET Framework 4.0、4.5、4.5.1、4.5.2、4.6、4.6.1、4.6.2、4.7、4.7。 1、4.7.2、4.8、4.8.1

Answer 14

我相信你应该避免像 WMI 和 LINQ 这样的臃肿的东西..并且你最终必须这样做，以便在你进行的过程中获得更多的信息，而臃肿的 API 和框架无法满足这些信息。

只需调用一个 dll 来调用并提取 CPUID 信息。 C++/CLI 或 pinvoke 就可以，并获取您需要的有关供应商的所有信息。 首先您需要查看该指令是否受支持（99% 的情况下是支持的）。

要快速启动和运行，请检查 intel 站点上的 wincpuid 示例，并从那里提取 cpuid.h 中的部分。 只有 2 家供应商，其中一家在内存延迟方面表现出色，而另一家则不然（例如本机代码与托管代码）。 所以你会在其他架构等上遇到 Mono 的问题（顺便说一句谁没有）。 至于 x64，您已经知道它，或者只是获取 corflags（它已经存在并通过 .NET 发行版杀死您的客户硬盘驱动器）..

(http://software.intel.com/en-us/articles/api-detects-ia-32 -和-x64-平台-cpu-特性/)

Answer 15

这就是我所做的：

public static bool Isx86()
{
    return (Environment.ExpandEnvironmentVariables("%ProgramFiles(x86)%").Length == 0);
}

如果您使用 64 位体系结构，您将有两个程序文件环境变量。 如果您使用的是 x86，则只有一个。