string os_platform = System.Environment.OSVersion.Platform.ToString();
这将返回“ Win32NT”。问题是，即使在64位Windows Vista上运行，它也会返回“ Win32NT”。
还有其他方法可以知道正确的平台（32或64位）吗？
请注意，在Windows 64位上作为32位应用程序运行时，它还应该检测到64位。
#1 楼
更新：正如Joel Coehoorn和其他人建议的那样，从.NET Framework 4.0开始，您只需检查Environment.Is64BitOperatingSystem。如果在32位.NET Framework 2.0中运行，IntPtr.Size将不会返回正确的值。在64位Windows上（它将返回32位）。如Microsoft的Raymond Chen所述，您必须首先检查是否在64位进程中运行（我认为在.NET中，您可以通过检查IntPtr来做到这一点。 .Size），并且如果您在32位进程中运行，则仍必须调用Win API函数IsWow64Process。如果返回true，则说明您正在64位Windows上运行32位进程。
Microsoft的Raymond Chen：
如何以编程方式检测您是否在64位Windows上运行
我解决方案：
static bool is64BitProcess = (IntPtr.Size == 8);
static bool is64BitOperatingSystem = is64BitProcess || InternalCheckIsWow64();
[DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool IsWow64Process(
[In] IntPtr hProcess,
[Out] out bool wow64Process
);
public static bool InternalCheckIsWow64()
{
if ((Environment.OSVersion.Version.Major == 5 && Environment.OSVersion.Version.Minor >= 1) ||
Environment.OSVersion.Version.Major >= 6)
{
using (Process p = Process.GetCurrentProcess())
{
bool retVal;
if (!IsWow64Process(p.Handle, out retVal))
{
return false;
}
return retVal;
}
}
else
{
return false;
}
}
#2 楼
.NET 4在Environment类中具有两个新属性，即Is64BitProcess和Is64BitOperatingSystem。有趣的是，如果使用Reflector，则可以看到它们在mscorlib的32位和64位版本中的实现方式有所不同。 32位版本的Is64BitProcess返回false，并通过P / Invoke为Is64BitOperatingSystem调用IsWow64Process。 64位版本仅对两者返回true。评论
为什么不下载Reflector，而不是Reflector。然后，您将获得注释和其他“注释”。
– AMissico
2011年7月25日在16:39
根据参考资料，它执行以下操作：if（IntPtr.Size == 8）返回true；否则，返回true。 if（！DoesWin32MethodExist（...，“ IsWow64Process”））返回false;返回IsWow64Process（GetCurrentProcess（））; （伪代码）
–多项式
2012年1月19日在22:33
真好如果用户使用的是.NET 4.0，则绝对是正确的答案（即Environment.Is64BitOperatingSystem）。 -.NET 3.5中似乎没有FYI属性。
– BrainSlugs83
13年5月30日在0:49
这不能回答具体说.Net 2.0的问题
– abbottdev
15年7月24日在8:43
.NET Core已根据MIT许可证发布，这意味着您可以阅读Is64BitProcess和Is64BitOperatingSystem的源代码（2.0版的链接）。
–克里斯蒂安·丘皮图
18年2月16日在6:09
#3 楼
如果使用的是.NET Framework 4.0，则很容易：Environment.Is64BitOperatingSystem
请参阅Environment.Is64BitOperatingSystem属性（MSDN）。
评论
对于极客，使用IsWow64Process（...）的内部实现referencesource.microsoft.com/#mscorlib/system/…
– Zyo
15年11月29日在4:04
#4 楼
这只是Bruno Lopez上面建议的实现，但是可以在Win2k和所有WinXP Service Pack上使用。只是觉得我会张贴它，所以其他人没有用手滚动它。 （本来可以发表评论，但我是新用户！）[DllImport("kernel32", SetLastError = true, CallingConvention = CallingConvention.Winapi)]
public extern static IntPtr LoadLibrary(string libraryName);
[DllImport("kernel32", SetLastError = true, CallingConvention = CallingConvention.Winapi)]
public extern static IntPtr GetProcAddress(IntPtr hwnd, string procedureName);
private delegate bool IsWow64ProcessDelegate([In] IntPtr handle, [Out] out bool isWow64Process);
public static bool IsOS64Bit()
{
if (IntPtr.Size == 8 || (IntPtr.Size == 4 && Is32BitProcessOn64BitProcessor()))
{
return true;
}
else
{
return false;
}
}
private static IsWow64ProcessDelegate GetIsWow64ProcessDelegate()
{
IntPtr handle = LoadLibrary("kernel32");
if ( handle != IntPtr.Zero)
{
IntPtr fnPtr = GetProcAddress(handle, "IsWow64Process");
if (fnPtr != IntPtr.Zero)
{
return (IsWow64ProcessDelegate)Marshal.GetDelegateForFunctionPointer((IntPtr)fnPtr, typeof(IsWow64ProcessDelegate));
}
}
return null;
}
private static bool Is32BitProcessOn64BitProcessor()
{
IsWow64ProcessDelegate fnDelegate = GetIsWow64ProcessDelegate();
if (fnDelegate == null)
{
return false;
}
bool isWow64;
bool retVal = fnDelegate.Invoke(Process.GetCurrentProcess().Handle, out isWow64);
if (retVal == false)
{
return false;
}
return isWow64;
}
#5 楼
完整的答案是这样的（来自stefan-mg，ripper234和BobbyShaftoe的答案）： [DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool IsWow64Process([In] IntPtr hProcess, [Out] out bool lpSystemInfo);
private bool Is64Bit()
{
if (IntPtr.Size == 8 || (IntPtr.Size == 4 && Is32BitProcessOn64BitProcessor()))
{
return true;
}
else
{
return false;
}
}
private bool Is32BitProcessOn64BitProcessor()
{
bool retVal;
IsWow64Process(Process.GetCurrentProcess().Handle, out retVal);
return retVal;
}
首先检查您是否在64位进程中。如果不是，请检查32位进程是否为Wow64Process。
评论
在Win2000和WinXP SP1及更低版本下，此操作将失败。在调用IsWow64Process（）函数之前，需要检查它是否存在，因为它仅在XP SP2和Vista / Win7中引入。
–user9876
09年11月16日在12:19
@ user9876，是否（还是曾经）有人仍将这些古董系统作为目标？
–CMircea
2011年4月26日在20:58
此示例无法处理由Process.GetCurrentProcess（）返回的Process实例。
–乔
2011年9月9日18:20
#6 楼
Microsoft已为此提供了代码示例：http://1code.codeplex.com/SourceControl/changeset/view/39074#842775
它看起来像这样：
/// <summary>
/// The function determines whether the current operating system is a
/// 64-bit operating system.
/// </summary>
/// <returns>
/// The function returns true if the operating system is 64-bit;
/// otherwise, it returns false.
/// </returns>
public static bool Is64BitOperatingSystem()
{
if (IntPtr.Size == 8) // 64-bit programs run only on Win64
{
return true;
}
else // 32-bit programs run on both 32-bit and 64-bit Windows
{
// Detect whether the current process is a 32-bit process
// running on a 64-bit system.
bool flag;
return ((DoesWin32MethodExist("kernel32.dll", "IsWow64Process") &&
IsWow64Process(GetCurrentProcess(), out flag)) && flag);
}
}
/// <summary>
/// The function determins whether a method exists in the export
/// table of a certain module.
/// </summary>
/// <param name="moduleName">The name of the module</param>
/// <param name="methodName">The name of the method</param>
/// <returns>
/// The function returns true if the method specified by methodName
/// exists in the export table of the module specified by moduleName.
/// </returns>
static bool DoesWin32MethodExist(string moduleName, string methodName)
{
IntPtr moduleHandle = GetModuleHandle(moduleName);
if (moduleHandle == IntPtr.Zero)
{
return false;
}
return (GetProcAddress(moduleHandle, methodName) != IntPtr.Zero);
}
[DllImport("kernel32.dll")]
static extern IntPtr GetCurrentProcess();
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
static extern IntPtr GetModuleHandle(string moduleName);
[DllImport("kernel32", CharSet = CharSet.Auto, SetLastError = true)]
static extern IntPtr GetProcAddress(IntPtr hModule,
[MarshalAs(UnmanagedType.LPStr)]string procName);
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool IsWow64Process(IntPtr hProcess, out bool wow64Process);
还提供WMI版本（用于测试远程计算机）。
评论
请注意，此代码是根据Microsoft Public License授权的。
– ladenedge
2011-09-12 16:28
没有托管.net的WMI版本？我想看看，到目前为止还没有找到
– JohnZaj
2012年1月28日6:19
#7 楼
您还可以检查PROCESSOR_ARCHITECTURE环境变量。它不存在或在32位Windows上设置为“ x86”。
评论
仅仅因为您拥有64位处理器并不意味着您拥有64位操作系统
–大卫
13年5月9日在7:22
@David这将报告Windows的处理器体系结构；不是CPU。请参阅此页上“代码”处的详细说明：andrewensley.com/2009/06/c-detect-windows-os-part-1
–安德鲁·恩斯利（Andrew Ensley）
13年5月9日在21:02
只需加上2美分，当您运行此命令时，您的应用程序就配置为首选32位，并且将任何CPU用作平台目标，那么您将获得x86，但是如果取消选择首选32位，则将获得AMD64。
– XAMlMAX
18年8月10日在12:32
#8 楼
来自Chriz Yuen博客C＃.Net 4.0引入了两个新的环境属性
Environment.Is64BitOperatingSystem;
Environment.Is64BitProcess;
请注意当心同时使用这两个属性。
在Windows 7 64位计算机上进行测试
//Workspace: Target Platform x86
Environment.Is64BitOperatingSystem True
Environment.Is64BitProcess False
//Workspace: Target Platform x64
Environment.Is64BitOperatingSystem True
Environment.Is64BitProcess True
//Workspace: Target Platform Any
Environment.Is64BitOperatingSystem True
Environment.Is64BitProcess True
#9 楼
最快的方法：if(IntPtr.Size == 8) {
// 64 bit machine
} else if(IntPtr.Size == 4) {
// 32 bit machine
}
注意：这是非常直接的，并且仅当程序不强制将程序作为32位进程强制执行时（例如，通过在项目设置中为
<Prefer32Bit>true</Prefer32Bit>）。评论
这将行不通-如果在64位Windows上以32位.NET Framework 2.0运行，它将返回32位。
– Stefan Schultze
08年12月3日在10:11
是的，我忘记了这种情况。我已经编辑了问题以提及这一点。谢谢stefan-mg。
– Marc
08年12月3日在10:18
这是不正确的。该平台可能是64位，但您仍在32位模式下运行。
–塞巴斯蒂安·古德（Sebastian Good）
2011年8月10日19:30
#10 楼
试试这个：Environment.Is64BitOperatingSystem
Environment.Is64BitProcess
评论
感谢您的输入，但是由于已经给出了此解决方案，因此请在发布之前阅读可用的答案。还要注意，最初的问题是关于.net 2的，它没有这两个属性，而这仅是.net 4引入的。
– Marc
2013年4月9日在6:13
#11 楼
@foobar：没错，这太简单了；）在99％的情况下，系统管理员背景薄弱的开发人员最终都无法意识到Microsoft始终为任何人提供的枚举Windows的功能。
在这种情况下，系统管理员将始终编写更好，更简单的代码。在正确的系统上返回正确的值：
System.Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE")
这将在32位Windows上返回“ X86”，在64位Windows上返回“ AMD64”。 />
评论
您的解决方案在MacBook Pro上返回x86，该MacBook Pro带有运行Bootcamp并带有Widows 7 Ultimate分区的Intel i7-3720QM微处理器。 Stefan Schultze的解决方案正确地将处理器标识为64位。我确定您的解决方案可以在99％的基于Windows的PC上运行。 +1尝试。
–马克·克拉姆（Mark Kram）
2012年7月15日在0:39
不。在Windows 7 Pro（64位操作系统）上返回“ x86”。
– Hagai L
2012年12月24日13:55
#12 楼
使用dotPeek有助于查看框架实际上是如何完成的。考虑到这一点，这就是我想出的内容：public static class EnvironmentHelper
{
[DllImport("kernel32.dll")]
static extern IntPtr GetCurrentProcess();
[DllImport("kernel32.dll")]
static extern IntPtr GetModuleHandle(string moduleName);
[DllImport("kernel32")]
static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
[DllImport("kernel32.dll")]
static extern bool IsWow64Process(IntPtr hProcess, out bool wow64Process);
public static bool Is64BitOperatingSystem()
{
// Check if this process is natively an x64 process. If it is, it will only run on x64 environments, thus, the environment must be x64.
if (IntPtr.Size == 8)
return true;
// Check if this process is an x86 process running on an x64 environment.
IntPtr moduleHandle = GetModuleHandle("kernel32");
if (moduleHandle != IntPtr.Zero)
{
IntPtr processAddress = GetProcAddress(moduleHandle, "IsWow64Process");
if (processAddress != IntPtr.Zero)
{
bool result;
if (IsWow64Process(GetCurrentProcess(), out result) && result)
return true;
}
}
// The environment must be an x86 environment.
return false;
}
}
示例用法：
EnvironmentHelper.Is64BitOperatingSystem();
#13 楼
使用以下两个环境变量（伪代码）：if (PROCESSOR_ARCHITECTURE = x86 &&
isDefined(PROCESSOR_ARCHITEW6432) &&
PROCESSOR_ARCHITEW6432 = AMD64) {
//64 bit OS
}
else
if (PROCESSOR_ARCHITECTURE = AMD64) {
//64 bit OS
}
else
if (PROCESSOR_ARCHITECTURE = x86) {
//32 bit OS
}
请参阅博客文章HOWTO：检测进程位。
评论
您是否看到有关.NET而不是C / C ++的问题？而且，这是编译时而不是运行时检查。此外，代码正在执行分配，而不是进行比较。
– dvallejo
2013年1月11日在22:22
这段代码可在.NET（在2.0上测试）上工作。可以通过以下方式访问Env变量：Environment.GetEnvironmentVariable（“ PROCESSOR_ARCHITECTURE”）; Environment.GetEnvironmentVariable（“ PROCESSOR_ARCHITEW6432”）;
– andrew.fox
2013年6月7日9:10
#14 楼
我在许多操作系统上成功使用了此检查：private bool Is64BitSystem
{
get
{
return Directory.Exists(Environment.ExpandEnvironmentVariables(@"%windir%\SysWOW64"));
}
}
无论操作系统的语言如何，此文件夹始终被命名为“ SysWOW64”。这适用于.NET Framework 1.1或更高版本。
评论
是什么让我作为具有管理权限的用户无法在32位操作系统的％windir％上创建一个名为SysWOW64的文件夹？文件夹的存在恰好意味着：该文件夹存在。
– cogumel0
18年6月13日在12:15
用户有意创建此类文件夹的机会是什么？这只是检查操作系统是否为x64的另一种方式。
–亚历山大·迪库（Alexandru Dicu）
18年7月10日在11:25
您的计算机感染病毒的机会是什么？由于机会很小，因此最好不要安装任何保护措施……编程并不是要创建某些东西，而这些东西在已知的情况下失败的可能性很小。这是关于创建一些在不知不觉中失败的可能性很小的东西，然后进行修复。第一个称为错误的编程/错误的实现，第二个称为错误。
– cogumel0
18年7月23日在15:47
@AlexandruDicu您应该在答案中提到这种方法不是100％准确的，并且如果文件夹是由任何第三方应用程序或用户有意创建的，则仍然存在错误输出的风险。
–拉杰什·米什拉（Rajesh Mishra）
19-10-15在7:22
#15 楼
我需要执行此操作，但是我还需要能够以管理员身份远程执行此操作，无论哪种情况，这对我来说似乎都很不错： public static bool is64bit(String host)
{
using (var reg = RegistryKey.OpenRemoteBaseKey(RegistryHive.LocalMachine, host))
using (var key = reg.OpenSubKey(@"Software\Microsoft\Windows\CurrentVersion\"))
{
return key.GetValue("ProgramFilesDir (x86)") !=null;
}
}
#16 楼
这是一个基于Microsoft代码的解决方案，位于http://1code.codeplex.com/SourceControl/changeset/view/39074#842775。它使用扩展方法来简化代码重用。一些可能的用法如下所示：
bool bIs64BitOS = System.Environment.OSVersion.IsWin64BitOS();
bool bIs64BitProc = System.Diagnostics.Process.GetCurrentProcess().Is64BitProc();
//Hosts the extension methods
public static class OSHelperTools
{
/// <summary>
/// The function determines whether the current operating system is a
/// 64-bit operating system.
/// </summary>
/// <returns>
/// The function returns true if the operating system is 64-bit;
/// otherwise, it returns false.
/// </returns>
public static bool IsWin64BitOS(this OperatingSystem os)
{
if (IntPtr.Size == 8)
// 64-bit programs run only on Win64
return true;
else// 32-bit programs run on both 32-bit and 64-bit Windows
{ // Detect whether the current process is a 32-bit process
// running on a 64-bit system.
return Process.GetCurrentProcess().Is64BitProc();
}
}
/// <summary>
/// Checks if the process is 64 bit
/// </summary>
/// <param name="os"></param>
/// <returns>
/// The function returns true if the process is 64-bit;
/// otherwise, it returns false.
/// </returns>
public static bool Is64BitProc(this System.Diagnostics.Process p)
{
// 32-bit programs run on both 32-bit and 64-bit Windows
// Detect whether the current process is a 32-bit process
// running on a 64-bit system.
bool result;
return ((DoesWin32MethodExist("kernel32.dll", "IsWow64Process") && IsWow64Process(p.Handle, out result)) && result);
}
/// <summary>
/// The function determins whether a method exists in the export
/// table of a certain module.
/// </summary>
/// <param name="moduleName">The name of the module</param>
/// <param name="methodName">The name of the method</param>
/// <returns>
/// The function returns true if the method specified by methodName
/// exists in the export table of the module specified by moduleName.
/// </returns>
static bool DoesWin32MethodExist(string moduleName, string methodName)
{
IntPtr moduleHandle = GetModuleHandle(moduleName);
if (moduleHandle == IntPtr.Zero)
return false;
return (GetProcAddress(moduleHandle, methodName) != IntPtr.Zero);
}
[DllImport("kernel32.dll")]
static extern IntPtr GetCurrentProcess();
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
static extern IntPtr GetModuleHandle(string moduleName);
[DllImport("kernel32", CharSet = CharSet.Auto, SetLastError = true)]
static extern IntPtr GetProcAddress(IntPtr hModule, [MarshalAs(UnmanagedType.LPStr)]string procName);
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool IsWow64Process(IntPtr hProcess, out bool wow64Process);
}
评论
CodePlex链接似乎已损坏。
– Peter Mortensen
13年3月21日在19:37
#17 楼
这是此页中使用DllImport的C＃直接方法。[DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool IsWow64Process([In] IntPtr hProcess, [Out] out bool lpSystemInfo);
public static bool Is64Bit()
{
bool retVal;
IsWow64Process(Process.GetCurrentProcess().Handle, out retVal);
return retVal;
}
评论
您仍然需要首先检查指针大小，否则它只是检查它是否在64位系统上是32位进程
– Bruno Lopes
2009年3月25日12:41
由于IsWow64Process不存在，因此在旧版操作系统上也会崩溃。
–多项式
2012年1月19日在22:37
#18 楼
我正在使用以下代码。注意：它是为AnyCPU项目制作的。 public static bool Is32bitProcess(Process proc) {
if (!IsThis64bitProcess()) return true; // We're in 32-bit mode, so all are 32-bit.
foreach (ProcessModule module in proc.Modules) {
try {
string fname = Path.GetFileName(module.FileName).ToLowerInvariant();
if (fname.Contains("wow64")) {
return true;
}
} catch {
// What on earth is going on here?
}
}
return false;
}
public static bool Is64bitProcess(Process proc) {
return !Is32bitProcess(proc);
}
public static bool IsThis64bitProcess() {
return (IntPtr.Size == 8);
}
#19 楼
我发现这是检查系统平台和过程的最佳方法：bool 64BitSystem = Environment.Is64BitOperatingSystem;
bool 64BitProcess = Environment.Is64BitProcess;
对于64位系统，第一个属性返回true，否则返回false对于32位。
第二个属性对于64位进程返回true，对于32位返回false。
需要这两个属性是因为可以运行32位进程在64位系统上，因此您需要检查系统和进程。
评论
如果要在c＃中构建变量名，请在变量名前加上_或字母（就我的观点而言，变量名不要以c＃中的数字开头！）
–克里斯
2014年5月5日17:27
#20 楼
很好，但这也应该从env开始起作用：也许;-) #21 楼
这是Windows管理规范（WMI）的方法：string _osVersion = "";
string _osServicePack = "";
string _osArchitecture = "";
ManagementObjectSearcher searcher = new ManagementObjectSearcher("select * from Win32_OperatingSystem");
ManagementObjectCollection collection = searcher.Get();
foreach (ManagementObject mbo in collection)
{
_osVersion = mbo.GetPropertyValue("Caption").ToString();
_osServicePack = string.Format("{0}.{1}", mbo.GetPropertyValue("ServicePackMajorVersion").ToString(), mbo.GetPropertyValue("ServicePackMinorVersion").ToString());
try
{
_osArchitecture = mbo.GetPropertyValue("OSArchitecture").ToString();
}
catch
{
// OSArchitecture only supported on Windows 7/Windows Server 2008
}
}
Console.WriteLine("osVersion : " + _osVersion);
Console.WriteLine("osServicePack : " + _osServicePack);
Console.WriteLine("osArchitecture: " + _osArchitecture);
/////////////////////////////////////////
// Test on Windows 7 64-bit
//
// osVersion : Microsoft Windows 7 Professional
// osservicePack : 1.0
// osArchitecture: 64-bit
/////////////////////////////////////////
// Test on Windows Server 2008 64-bit
// --The extra r's come from the registered trademark
//
// osVersion : Microsoftr Windows Serverr 2008 Standard
// osServicePack : 1.0
// osArchitecture: 64-bit
/////////////////////////////////////////
// Test on Windows Server 2003 32-bit
// --OSArchitecture property not supported on W2K3
//
// osVersion : Microsoft(R) Windows(R) Server 2003, Standard Edition
// osServicePack : 2.0
// osArchitecture:
#22 楼
OSInfo.Bitsusing System;
namespace CSharp411
{
class Program
{
static void Main( string[] args )
{
Console.WriteLine( "Operation System Information" );
Console.WriteLine( "----------------------------" );
Console.WriteLine( "Name = {0}", OSInfo.Name );
Console.WriteLine( "Edition = {0}", OSInfo.Edition );
Console.WriteLine( "Service Pack = {0}", OSInfo.ServicePack );
Console.WriteLine( "Version = {0}", OSInfo.VersionString );
Console.WriteLine( "Bits = {0}", OSInfo.Bits );
Console.ReadLine();
}
}
}
评论
很好，但是此类来自Microsoft.SUS。Microsoft.UpdateServices.Administration命名空间。我不希望仅出于了解平台位而包含此参考。
– Marc
10年4月22日在14:10
“ C：\ Program Files \ Microsoft.NET \ SDK \ v2.0 64bit \ LateBreaking \ PlatformInvoke \ WinAPIs \ OSInfo \ CS \ OSInfoCS.sln”
– AMissico
2011年7月25日在17:09
#23 楼
在您的项目中的类中包含以下代码： [DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool IsWow64Process([In] IntPtr hProcess, [Out] out bool wow64Process);
public static int GetBit()
{
int MethodResult = "";
try
{
int Architecture = 32;
if ((Environment.OSVersion.Version.Major == 5 && Environment.OSVersion.Version.Minor >= 1) || Environment.OSVersion.Version.Major >= 6)
{
using (Process p = Process.GetCurrentProcess())
{
bool Is64Bit;
if (IsWow64Process(p.Handle, out Is64Bit))
{
if (Is64Bit)
{
Architecture = 64;
}
}
}
}
MethodResult = Architecture;
}
catch //(Exception ex)
{
//ex.HandleException();
}
return MethodResult;
}
按如下方式使用：
string Architecture = "This is a " + GetBit() + "bit machine";
#24 楼
使用它来获取已安装的Windows体系结构：string getOSArchitecture()
{
string architectureStr;
if (Directory.Exists(Environment.GetFolderPath(
Environment.SpecialFolder.ProgramFilesX86))) {
architectureStr ="64-bit";
}
else {
architectureStr = "32-bit";
}
return architectureStr;
}
评论
我在w7x64 vs.net 2010上没有ProgramFilesX86属性
–克里斯蒂安·卡苏特（Christian Casutt）
13年8月15日在10:14
#25 楼
鉴于公认的答案非常复杂。有更简单的方法。我的是alexandrudicu的分析的变体。鉴于64位Windows在程序文件（x86）中安装了32位应用程序，则可以使用环境变量（以弥补不同的本地化）来检查该文件夹是否存在
/>
例如
private bool Is64BitSystem
{
get
{
return Directory.Exists(Environment.ExpandEnvironmentVariables(@"%PROGRAMFILES(X86)%"));
}
}
对我来说，这是更快，更简单的方法。鉴于我也希望根据操作系统版本访问该文件夹下的特定路径。
评论
可接受的答案是.NET 2.0。如果您使用的是.NET 4.0或更高版本，请使用Environment.Is64BitOperatingSystem，您可以在投票中以最多的票数找到它。
– Marc
17年11月7日在10:19
是的，我的也适用于.net 2.0。
– John Demetriou
17年11月8日在11:44
#26 楼
享受;-)Function Is64Bit() As Boolean
Return My.Computer.FileSystem.SpecialDirectories.ProgramFiles.Contains("Program Files (x86)")
End Function
评论
-1，因为它不适用于本地化的Windows安装。并且它使用VB.net，而问题被标记为C＃。
– Marc
2013年12月4日15:27
#27 楼
只要看看是否存在“ C：\ Program Files（x86）”即可。如果不是，则您使用的是32位操作系统。如果是这样，则操作系统为64位（Windows Vista或Windows 7）。看起来很简单...评论
确保从Win32 API检索正确的本地化目录名称，而不是对其进行硬编码。
–克里斯蒂安·海特（Christian Hayter）
2010-09-17在8:42
我会说这是个好主意，但您不能假设用户出于某些晦涩的原因永远不会这样做。
–GurdeepS
2011年4月2日在22:27
现在，某些编写不佳的应用程序不考虑体系结构，直接安装到“程序文件（x86）”。例如，感谢SOAPSonar，我在32位计算机上有了该目录。
– ladenedge
2011年9月12日下午16:18
#28 楼
我使用：Dim drivelet As String = Application.StartupPath.ToString
If Directory.Exists(drivelet(0) & ":\Program Files (x86)") Then
MsgBox("64bit")
Else
MsgBox("32bit")
End if
这将获得启动应用程序的路径，以防万一您将其安装在计算机上的各个位置。另外，您可以只执行常规的
C:\路径，因为99.9％的计算机在C:\中安装了Windows。评论
非常糟糕的方法。如果将来将此目录重命名怎么办？ Windows的本地化版本如何？在Windows XP中，德语“程序文件”称为“程序”。我不确定，但是XP 64可能因此将其称为“ Programme（x86）”。
– Marc
2011年11月14日12:16
我不建议这样做，但可以通过扩展环境变量％ProgramFiles（x86）％来解决本地化问题
–马修·洛克（Matthew Lock）
2012年4月2日在7:58
#29 楼
我使用以下版本： public static bool Is64BitSystem()
{
if (Directory.Exists(Environment.GetEnvironmentVariable("Program Files (x86)"))) return true;
else return false;
}
评论
由于本地程序文件夹的名称，这在非英语XP版本上不起作用。
–DanielSchlößer
2012年4月19日在9:45
但是即使是64位系统也有此文件夹哈哈
–carefulnow1
16年8月7日，下午3:23
评论
当在32位操作系统上运行时，对IsWow64Process的任何调用都会引发异常，因为kernel32.dll中缺少该条目。您应该在1code.codeplex.com/SourceControl/changeset/view/39074#842775上查看来自codeplex的解决方案。我也有基于此页面底部列出的代码的解决方案，如果您关心的话，可以使用扩展方法重用代码。
– dmihailescu
2011年2月2日在18:29
Win XP SP2中引入了IsWow64Process。如果您需要XP SP2或任何更高版本，则此代码可以正常工作。
– Marc
2011年2月4日在9:12
@dmihailescu，您可以在调用IsWow64Process之前使用DoesWin32MethodExist，这是is64BitOperatingSystem的.net 4.0实现的功能。
– noobish
2011-3-18在23:04
您的解决方案在使用Widows 7 Ultimate分区，运行Bootcamp的Intel i7-3720QM微处理器的MacBook Pro上返回正确的值。 +1
–马克·克拉姆（Mark Kram）
2012年7月15日，0：40
仅供参考：从.Net 4.0开始，您只需检查System.Environment.Is64BitOperatingSystem。您可以将其编辑为答案，还是可以授予我权限将其编辑为答案？
–乔尔·科恩（Joel Coehoorn）
13年11月21日在15:01