如何使用.NET检测Windows 64位平台?


267

.NET 2.0 C#应用程序中,我使用以下代码来检测操作系统平台:

string os_platform = System.Environment.OSVersion.Platform.ToString();

这将返回“ Win32NT”。问题是,即使在64位Windows Vista上运行,它也会返回“ Win32NT”。

还有其他方法可以知道正确的平台(32或64位)吗?

请注意,当在Windows 64位上作为32位应用程序运行时,它也应该检测到64位。

Answers:


199

如果在64位Windows上的32位.NET Framework 2.0中运行,IntPtr.Size将不会返回正确的值(它将返回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;
    }
}

7
在32位OS上运行时,对IsWow64Process的任何调用都将引发异常,因为kernel32.dll中缺少该条目。您应该在1code.codeplex.com/SourceControl/changeset/view/39074#842775上检查来自codeplex的解决方案。我也有基于此页面底部列出的代码的解决方案,如果您关心的话,可以使用扩展方法。重用代码。
dmihailescu,2011年

7
Win XP SP2中引入了IsWow64Process。如果您需要XP SP2或任何更高版本,则此代码可以正常工作。
Marc

3
@dmihailescu,您可以在调用IsWow64Process之前使用DoesWin32MethodExist,这是is64BitOperatingSystem的.net 4.0实现的功能。
noobish

4
您的解决方案在使用Widows 7 Ultimate分区,运行Bootcamp的Intel i7-3720QM微处理器的MacBook Pro上返回正确的值。+1
马克·克拉姆

11
仅供参考:从.Net 4.0开始,您只需检查即可System.Environment.Is64BitOperatingSystem。您可以将其编辑为答案,还是允许我将其编辑为答案?
Joel Coehoorn

241

.NET 4在Environment类中具有两个新属性,即Is64BitProcessIs64BitOperatingSystem。有趣的是,如果使用Reflector,则可以看到它们在mscorlib的32位和64位版本中的实现方式有所不同。32位版本的Is64BitProcess返回false,并通过P / Invoke为Is64BitOperatingSystem调用IsWow64Process。64位版本仅对两者返回true。


5
为什么不下载Reflector,而不是Reflector。然后,您将获得注释和其他“注释”。
2011年

3
根据参考资料,它执行以下操作:(if (IntPtr.Size == 8) return true; if(!DoesWin32MethodExist(...,"IsWow64Process")) return false; return IsWow64Process(GetCurrentProcess());伪代码)
多项式2012年

5
真好 如果用户使用的是.NET 4.0,则绝对是正确的答案(即Environment.Is64BitOperatingSystem)。-.NET 3.5中似乎没有FYI属性。
BrainSlugs83

4
这不能回答具体说.Net 2.0的问题
abbottdev

.NET的核心已经在MIT许可下,这意味着你可以阅读源代码发布Is64BitProcessIs64BitOperatingSystem(2.0版链接)。
Cristian Ciupitu


51

这只是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;
}

49

完整答案是这样的(摘自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。


13
在Win2000和WinXP SP1及更低版本下,此操作将失败。在调用IsWow64Process()函数之前,需要检查它是否存在,因为它仅在XP SP2和Vista / Win7中引入。
user9876

2
@ user9876,是否(还是曾经)有人仍将这些古董系统作为目标?
CMircea 2011年

5
此示例无法处理由Process.GetCurrentProcess()返回的Process实例。

42

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版本可用(用于测试远程计算机)。


1
请注意,此代码是根据Microsoft Public License授权的
ladenedge 2011年

没有托管.net的WMI版本?我想看看,到目前为止还没有找到
JohnZaj 2012年

16

您也可以检查PROCESSOR_ARCHITECTURE环境变量。

它不存在,或在32位Windows上设置为“ x86”。

private int GetOSArchitecture()
{
    string pa = 
        Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE");
    return ((String.IsNullOrEmpty(pa) || 
             String.Compare(pa, 0, "x86", 0, 3, true) == 0) ? 32 : 64);
}

1
仅仅因为您拥有64位处理器并不意味着您就拥有64位操作系统
大卫,

2
@David这将报告Windows的处理器体系结构;不是CPU。请参阅从此页上的“代码”开始的详细说明:andrewensley.com/2009/06/c-detect-windows-os-part-1
Andrew Ensley

我想补充2美分,当你运行它,并且你的应用程序被配置为prefer 32-bitAny CPU为您Platform Target那么你会得到x86,但如果不勾选Prefer 32-bit它,你会再拿到AMD64
XAMlMAX

14

来自袁咏仪博客

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

12

最快的方法:

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

注意:这是非常直接的,只有在程序不强制将32位进程强制执行时(例如,通过<Prefer32Bit>true</Prefer32Bit>项目设置),才能在64位上正确运行。


32
这将行不通-如果在64位Windows上以32位.NET Framework 2.0运行,它将返回32位。
Stefan Schultze,

是的,我忘了这种情况。我已经编辑了问题以提及这一点。谢谢stefan-mg。
Marc

1
这是不正确的。该平台可能是64位,但您仍在32位模式下运行。
塞巴斯蒂安·古德

11

试试这个:

Environment.Is64BitOperatingSystem

Environment.Is64BitProcess

5
感谢您的输入,但由于已经提供了此解决方案,因此请在发布之前阅读可用的答案。另外请注意,原来的问题是关于.NET 2,不具有引入只有.NET 4这两个属性
马克·

9

@foobar:你是对的,这太容易了;)

在99%的情况下,系统管理员背景薄弱的开发人员最终都无法意识到Microsoft一直为任何人枚举Windows所提供的功能。

在这种情况下,系统管理员将始终编写更好,更简单的代码。

尽管如此,需要注意的一件事是,此环境变量的构建配置必须是AnyCPU才能在正确的系统上返回正确的值:

System.Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE")

在32位Windows上将返回“ X86”,在64位Windows上将返回“ AMD64”。


4
您的解决方案在MacBook Pro上返回x86,该MacBook Pro带有运行Bootcamp并带有Widows 7 Ultimate分区的Intel i7-3720QM微处理器。Stefan Schultze的解决方案正确地将处理器标识为64位。我确信您的解决方案可以在99%的基于Windows的PC上运行。+1尝试。
马克·克拉姆

不。在我的Windows 7专业版64位操作系统上返回“ x86”。
Hagai L 2012年

7

使用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();

6

使用以下两个环境变量(伪代码):

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年

该代码可在.NET(在2.0上测试)上工作。可以通过以下方式访问Env变量:Environment.GetEnvironmentVariable(“ PROCESSOR_ARCHITECTURE”); Environment.GetEnvironmentVariable(“ PROCESSOR_ARCHITEW6432”);
andrew.fox

5

我在许多操作系统上成功使用了此检查:

private bool Is64BitSystem
{
   get
   {
      return Directory.Exists(Environment.ExpandEnvironmentVariables(@"%windir%\SysWOW64"));
   }
}

不管操作系统使用哪种语言,该文件夹始终被命名为“ SysWOW64”。适用于.NET Framework 1.1或更高版本。


作为具有管理权限的用户,是什么阻止我在32位操作系统上创建SysWOW64%windir%上调用的文件夹?文件夹的存在恰恰意味着:该文件夹存在。
cogumel0

用户有意创建此类文件夹的机会是什么?这只是检查操作系统是否为x64的另一种方式。
亚历山德鲁·迪库

您的计算机感染病毒的机会是什么?因为机会是相当低的,最好不要安装任何保护,那么......编程是不是创造一些具有低机会明知失败。这是关于创建一些在不知不觉中失败的可能性很小的事情,然后进行修复。第一种称为不良编程/不良实现,第二种称为错误。
cogumel0

@AlexandruDicu您应该在答案中提及这种方法不是100%准确的,并且如果该文件夹是由任何第三方应用程序或用户有意创建的,则仍然存在错误输出的风险。
Rajesh Mishra

4

我需要这样做,但是我还需要能够以管理员身份远程执行此操作,无论哪种情况,这对我来说似乎都很好:

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

4

这是基于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

3

这是此页中使用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

1
由于IsWow64Process不存在,因此也会在较旧的操作系统上崩溃。
多项式2012年

3

我正在使用followin代码。注意:它是为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);
    }

2

我发现这是检查系统平台和过程的最佳方法:

bool 64BitSystem = Environment.Is64BitOperatingSystem;
bool 64BitProcess = Environment.Is64BitProcess;

第一个属性对于64位系统返回true,对于32位返回false。第二个属性对于64位进程返回true,对于32位返回false。

这两个属性的需要是因为您可以在64位系统上运行32位进程,因此需要同时检查系统和进程。


1
如果要在c#中构建变量名,请在变量名前添加_或字母(就我的想法而言,变量名不要以c#中的数字开头!)
克里斯

2

一切都很好,但是这也可以从env以下途径工作:

PROCESSOR_ARCHITECTURE=x86

..

PROCESSOR_ARCHITECTURE=AMD64

太容易了,也许;-)


2

这是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:

1

OSInfo.Bits

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

3
很好,但是此类来自Microsoft.SUS。Microsoft.UpdateServices.Administration命名空间。我不喜欢仅出于了解平台位而包含此参考。
Marc 2010年

“ C:\ Program Files \ Microsoft.NET \ SDK \ v2.0 64bit \ LateBreaking \ PlatformInvoke \ WinAPIs \ OSInfo \ CS \ OSInfoCS.sln”
AMissico 2011年

1

在您的项目的类中包含以下代码:

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

0

使用它来获取已安装的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

0

鉴于公认的答案非常复杂。有更简单的方法。我的是亚历山大·阿杜斯(Alexandrudicu)的作品的变体。假设64位Windows在程序文件(x86)中安装了32位应用程序,则可以使用环境变量检查该文件夹是否存在(以弥补不同的本地化)

例如

private bool Is64BitSystem
{
   get
   {
      return Directory.Exists(Environment.ExpandEnvironmentVariables(@"%PROGRAMFILES(X86)%"));
   }
}

对我来说这是更快,更简单的。鉴于我也希望基于操作系统版本访问该文件夹下的特定路径。


2
可接受的答案是.NET 2.0。如果您使用的是.NET 4.0或更高版本,请使用Environment.Is64BitOperatingSystem,您可以在投票中以最多的票数找到它。
马克

是的,我的也适用于.net 2.0。
约翰·德米特里

-2

请享用 ;-)

Function Is64Bit() As Boolean

    Return My.Computer.FileSystem.SpecialDirectories.ProgramFiles.Contains("Program Files (x86)")

End Function

-1,因为这不适用于本地化的Windows安装。并且它使用VB.net,而问题被标记为C#。
Marc

-3

只要看看是否存在“ C:\ Program Files(x86)”即可。如果不是,则您使用的是32位操作系统。如果支持,则操作系统为64位(Windows Vista或Windows 7)。看起来很简单...


5
确保从Win32 API检索正确的本地化目录名称,而不是对其进行硬编码。
克里斯蒂安·海特

我会说这是个好主意,但是您不能假设用户出于某种晦涩的原因永远不会这样做。
GurdeepS 2011年

2
现在,一些编写不佳的应用程序不考虑体系结构,直接安装到“程序文件(x86)”。例如,由于有了SOAPSonar,我在32位计算机上有了该目录。
ladenedge 2011年

-4

我用:

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%的计算机都安装了Windows C:\


8
非常糟糕的方法。如果将来将此目录重命名怎么办?Windows的本地化版本如何?在Windows XP中,德语“程序文件”称为“程序”。我不确定,但是XP 64可能因此将其称为“ Programme(x86)”。
马克

1
我不建议这样做,但可以通过扩展环境变量%ProgramFiles(x86)%来解决本地化问题
Matthew Lock

-7

我使用以下版本:

    public static bool Is64BitSystem()
    {
        if (Directory.Exists(Environment.GetEnvironmentVariable("Program Files (x86)"))) return true;
        else return false;
    }

6
由于本地程序文件夹的名称,这在非英语XP版本上不起作用。
DanielSchlößer2012年

但是,即使是64位系统也有此文件夹haha
now16年
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.