Làm cách nào để phát hiện nền tảng Windows 64 bit bằng .NET?

Trong ứng dụng .NET 2.0 C #, tôi sử dụng đoạn mã sau để phát hiện nền tảng hệ điều hành:

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

Điều này trả về "Win32NT". Vấn đề là nó trả về "Win32NT" ngay cả khi chạy trên Windows Vista 64-bit.

Có phương pháp nào khác để biết nền tảng chính xác (32 hoặc 64 bit) không?

Lưu ý rằng nó cũng sẽ phát hiện 64 bit khi chạy dưới dạng ứng dụng 32 bit trên Windows 64 bit.

IntPtr.Size sẽ không trả về giá trị chính xác nếu chạy trong .NET Framework 2.0 32 bit trên Windows 64 bit (nó sẽ trả về 32 bit).

Như Raymond Chen của Microsoft mô tả, trước tiên bạn phải kiểm tra xem có đang chạy trong quy trình 64 bit không (tôi nghĩ trong .NET bạn có thể làm như vậy bằng cách kiểm tra IntPtr.Size) và nếu bạn đang chạy trong quy trình 32 bit, bạn vẫn phải gọi hàm Win API IsWow64Process. Nếu điều này trả về đúng, bạn đang chạy trong quy trình 32 bit trên Windows 64 bit.

Raymond Chen của Microsoft: Cách phát hiện lập trình cho dù bạn đang chạy trên Windows 64 bit

Giải pháp của tôi:

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

.NET 4 có hai thuộc tính mới trong lớp Môi trường, Is64BitProcess và Is64BitOperatingSystem . Thật thú vị, nếu bạn sử dụng Reflector, bạn có thể thấy chúng được triển khai khác nhau trong các phiên bản 32 bit & 64 bit của mscorlib. Phiên bản 32 bit trả về sai cho Is64BitProcess và gọi IsWow64Process qua P / Gọi cho Is64BitOperatingSystem. Phiên bản 64 bit chỉ trả về đúng cho cả hai.

Nếu bạn đang sử dụng .NET Framework 4.0, thật dễ dàng:

Environment.Is64BitOperatingSystem

Xem thuộc tính môi trường.Is64BitOperatingSystem (MSDN).

Đây chỉ là một triển khai những gì được đề xuất ở trên bởi Bruno Lopez, nhưng hoạt động trên Win2k + tất cả các gói dịch vụ WinXP. Chỉ cần hình dung tôi sẽ đăng nó để người khác không phải cuộn nó bằng tay. (sẽ đăng dưới dạng nhận xét, nhưng tôi là người dùng mới!)

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

Câu trả lời đầy đủ là đây (được lấy từ cả hai câu trả lời của stefan-mg, ripper234 và 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;
    } 

Trước tiên hãy kiểm tra xem bạn có đang trong quá trình 64 bit không. Nếu bạn không phải, hãy kiểm tra xem quy trình 32 bit có phải là Wow64Process không.

Microsoft đã đặt một mẫu mã cho việc này:

http://1code.codeplex.com/SourceControl/changeset/view/39074#842775

Nó trông như thế này:

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

Cũng có sẵn phiên bản WMI (để thử nghiệm các máy từ xa).

Bạn cũng có thể kiểm tra PROCESSOR_ARCHITECTUREbiến môi trường.

Nó không tồn tại hoặc được đặt thành "x86" trên Windows 32 bit.

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

Từ blog của Chriz Yuen

C # .Net 4.0 Giới thiệu hai thuộc tính môi trường mới Môi trường.Is64BitOperatingSystem; Môi trường.Is64BitProcess;

Hãy cẩn thận khi bạn sử dụng cả hai tài sản này. Kiểm tra trên máy Windows 7 64 bit

//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

Cách nhanh nhất:

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

Lưu ý: điều này rất trực tiếp và chỉ hoạt động chính xác trên 64 bit nếu chương trình không bắt buộc thực thi như một quy trình 32 bit (ví dụ: thông qua<Prefer32Bit>true</Prefer32Bit>trong cài đặt dự án).

Thử cái này:

Environment.Is64BitOperatingSystem

Environment.Is64BitProcess

@foobar: Bạn nói đúng, quá dễ dàng;)

Trong 99% trường hợp, các nhà phát triển có nền tảng quản trị viên hệ thống yếu cuối cùng không nhận ra sức mạnh mà Microsoft luôn cung cấp cho bất kỳ ai để liệt kê Windows.

Quản trị viên hệ thống sẽ luôn viết mã tốt hơn và đơn giản hơn khi nói đến điểm như vậy.

Tuy nhiên, một điều cần lưu ý, cấu hình xây dựng phải là AnyCPU cho biến môi trường này để trả về các giá trị chính xác trên các hệ thống chính xác:

System.Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE")

Điều này sẽ trả về "X86" trên Windows 32 bit và "AMD64" trên Windows 64 bit.

Sử dụng dotPeek giúp xem khung công tác thực sự như thế nào. Với ý nghĩ đó, đây là những gì tôi nghĩ ra:

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

Ví dụ sử dụng:

EnvironmentHelper.Is64BitOperatingSystem();

Sử dụng hai biến môi trường này (mã giả):

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
        }

Tham khảo bài viết trên blog HOWTO: Phát hiện quá trình nhân chứng .

Tôi đã sử dụng kiểm tra này với thành công trên nhiều hệ điều hành:

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

Thư mục này luôn được đặt tên là "SysWOW64", bất kể ngôn ngữ của hệ điều hành. Điều này hoạt động cho .NET Framework 1.1 trở lên.

Tôi cần phải làm điều này, nhưng tôi cũng cần có khả năng là một quản trị viên thực hiện nó từ xa, trong trường hợp này có vẻ như hoạt động khá độc đáo đối với tôi:

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

Đây là một giải pháp dựa trên mã của Microsoft tại http://1code.codeplex.com/SourceControl/changeset/view/39074#842775 . Nó sử dụng các phương thức mở rộng để tái sử dụng mã dễ dàng.

Một số cách sử dụng có thể được hiển thị dưới đây:

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

Đây là cách tiếp cận trực tiếp trong C # bằng cách sử dụng DLLImport từ trang này .

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

Tôi đang sử dụng mã followin. Lưu ý: Nó được tạo cho một dự án 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);
    }

Tôi thấy đây là cách tốt nhất để kiểm tra nền tảng của hệ thống và quy trình:

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

Thuộc tính đầu tiên trả về true cho hệ thống 64 bit và false cho 32 bit. Thuộc tính thứ hai trả về true cho quá trình 64 bit và false cho 32 bit.

Sự cần thiết của hai thuộc tính này là bởi vì bạn có thể chạy các quy trình 32 bit trên hệ thống 64 bit, do đó bạn sẽ cần kiểm tra cả hệ thống và quy trình.

Tất cả đều ổn, nhưng điều này cũng sẽ hoạt động từ env:

PROCESSOR_ARCHITECTURE=x86

..

PROCESSOR_ARCHITECTURE=AMD64

Quá dễ, có thể ;-)

Đây là cách tiếp cận Công cụ quản lý 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:

OSInfo.

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

Bao gồm các mã sau vào một lớp trong dự án của bạn:

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

Sử dụng nó như vậy:

string Architecture = "This is a " + GetBit() + "bit machine";

Sử dụng điều này để có được kiến ​​trúc Windows đã cài đặt:

string getOSArchitecture()
{
    string architectureStr;
    if (Directory.Exists(Environment.GetFolderPath(
                           Environment.SpecialFolder.ProgramFilesX86))) {
        architectureStr ="64-bit";
    }
    else {
        architectureStr = "32-bit";
    }
    return architectureStr;
}

Cho rằng câu trả lời được chấp nhận là rất phức tạp. Có những cách đơn giản hơn. Của tôi là một biến thể của anaswer alexandrudicu. Cho rằng các cửa sổ 64 bit cài đặt các ứng dụng 32 bit trong Tệp chương trình (x86), bạn có thể kiểm tra xem thư mục đó có tồn tại hay không, sử dụng các biến môi trường (để bù cho các nội địa hóa khác nhau)

ví dụ

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

Điều này đối với tôi là nhanh hơn và đơn giản hơn. Cho rằng tôi cũng muốn truy cập một đường dẫn cụ thể trong thư mục đó dựa trên phiên bản HĐH.

Thưởng thức ;-)

Function Is64Bit() As Boolean

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

End Function

Chỉ cần xem "C: \ Program Files (x86)" có tồn tại không. Nếu không, thì bạn đang ở trên hệ điều hành 32 bit. Nếu vậy, HĐH là 64 bit (Windows Vista hoặc Windows 7). Có vẻ như đủ đơn giản ...

Tôi sử dụng:

Dim drivelet As String = Application.StartupPath.ToString
If Directory.Exists(drivelet(0) & ":\Program Files (x86)") Then
    MsgBox("64bit")
Else
    MsgBox("32bit")
End if

Điều này nhận được đường dẫn ứng dụng của bạn được khởi chạy trong trường hợp bạn đã cài đặt nó ở nhiều nơi trên máy tính. Ngoài ra, bạn chỉ có thể thực hiện C:\đường dẫn chung vì 99,9% máy tính ngoài đó đã cài đặt Windows C:\.

Tôi sử dụng một phiên bản sau:

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