를 사용하여 Windows 64비트플랫폼을 검출하는 방법인터넷?

를 사용하여 Windows 64비트플랫폼을 검출하는 방법인터넷?

.NET 2.0 C# 어플리케이션에서는 다음 코드를 사용하여 운영체제 플랫폼을 검출합니다.

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

그러면 "Win32NT"가 반환됩니다.문제는 "Win32"가 반환된다는 것입니다.Windows Vista 64비트로 동작하고 있는 경우에서도, NT」를 사용할 수 있습니다.

올바른 플랫폼(32비트 또는 64비트)을 알 수 있는 다른 방법이 있습니까?

또, Windows 64 비트로 32 비트애플리케이션으로서 동작하고 있는 경우는, 64 비트를 검출할 필요가 있습니다.

.NET 4에는 환경 클래스에 Is64BitProcess와 Is64BitOperatingSystem이라는 두 가지 새로운 속성이 있습니다.흥미롭게도 리플렉터를 사용하면 32비트 및 64비트 버전의 mscorlib에서 구현되는 방식이 다르다는 것을 알 수 있습니다.32비트 버전은 Is64BitProcess에 대해 false를 반환하고 Is64BitOperatingSystem에 대해 P/Invoke를 통해 IsWow64Process를 호출합니다.64비트 버전에서는 둘 다 true가 반환됩니다.

업데이트: Joel Coehoorn과 다른 사람들이 제안하듯이, 에서 시작합니다.NET Framework 4.0에서는Environment.Is64BitOperatingSystem.

---

IntPtr.Size는 32비트로 실행 중인 경우 올바른 값을 반환하지 않습니다.64비트 Windows의 NET Framework 2.0 (32비트를 반환합니다).

Microsoft의 Raymond Chen이 설명한 바와 같이 64비트 프로세스에서 실행 중인지 여부를 먼저 확인해야 합니다(을 참조).NET IntPtr을 체크하면 됩니다.크기) 및 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;
    }
}

를 사용하고 있는 경우.NET Framework 4.0은 간단합니다.

Environment.Is64BitOperatingSystem

「환경」을 참조해 주세요.Is64Bit Operating System 속성(MSDN).

이것은 Bruno Lopez가 상기의 내용을 실장했을 뿐이지만, Win2000 + 모든 WinXP 서비스 팩에서 동작합니다.다른 사람들이 손으로 굴리지 않게 게시물을 올리려고 했어요.(댓글을 달았으면 좋았을 텐데, 저는 새로운 사용자입니다!)

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

전체 답은 다음과 같습니다(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비트 프로세스가 Wow64 프로세스인지 확인합니다.

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 버전도 있습니다.

'아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 이런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);
}

Chriz Yuen 블로그에서

C# . Net 4.0 2개의 새로운 환경 속성 환경이 도입되었습니다.Is64Bit Operating System, 환경.Is64Bit Process;

이 두 가지 물건을 모두 사용할 때는 주의해 주십시오.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

가장 빠른 방법:

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

주의: 이것은 매우 직접적이며 프로그램이 32비트 프로세스로 강제 실행하지 않는 경우에만 64비트로 올바르게 작동합니다(예: ~ ).<Prefer32Bit>true</Prefer32Bit>프로젝트 설정)에 액세스 합니다.

이것을 시험해 보세요.

Environment.Is64BitOperatingSystem

Environment.Is64BitProcess

@foobar:맞아요, 너무 쉬워요;)

99%의 경우 시스템 관리자 배경이 약한 개발자는 결국 Microsoft가 Windows를 열거하는 데 항상 제공해 온 힘을 깨닫지 못하고 있습니다.

시스템 관리자는 이러한 점에 있어서는 항상 더 좋고 간단한 코드를 작성합니다.

단, 이 환경변수가 올바른 시스템에서 올바른 값을 반환하려면 빌드 구성이 AnyCPU여야 합니다.

System.Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE")

32비트 Windows 에서는 「X86」, 64비트 Windows 에서는 「AMD64」가 반환됩니다.

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

다음의 2개의 환경 변수(의사 코드)를 사용합니다.

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: 프로세스 비트니스 검출을 참조해 주세요.

이 체크는 많은 운영 체제에서 성공적으로 사용되었습니다.

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

이 폴더의 이름은 운영 체제의 언어에 관계없이 항상 "SysWOW64"입니다.이것은 에 유효합니다.NET Framework 1.1 이후

이 조작은 필요하지만, 관리자로서 리모트에서도 실행할 수 있어야 합니다.어느 경우든, 이 조작은 나에게 있어서 꽤 효과가 있을 것 같습니다.

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

이 솔루션은 http://1code.codeplex.com/SourceControl/changeset/view/39074#842775에 있는 Microsoft 코드를 기반으로 합니다.코드를 쉽게 재사용할 수 있도록 확장 방법을 사용합니다.

사용법은 다음과 같습니다.

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

이 페이지에서 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; 
} 

팔로우인 코드를 사용하고 있습니다.주의: 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);
    }

시스템 플랫폼과 프로세스를 확인하는 가장 좋은 방법은 다음과 같습니다.

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

첫 번째 속성은 64비트 시스템의 경우 true, 32비트 시스템의 경우 false를 반환합니다.두 번째 속성은 64비트 프로세스의 경우 true, 32비트 프로세스의 경우 false를 반환합니다.

이 두 가지 속성이 필요한 이유는 64비트 시스템에서 32비트 프로세스를 실행할 수 있기 때문에 시스템과 프로세스를 모두 확인해야 하기 때문입니다.

좋아, 하지만 이 또한 다음에서 작동해야 해env:

PROCESSOR_ARCHITECTURE=x86

..

PROCESSOR_ARCHITECTURE=AMD64

너무 쉬울지도 몰라;-)

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

프로젝트의 클래스에 다음 코드를 포함합니다.

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

인스톨 되어 있는 Windows 아키텍처를 취득하려면 , 다음의 순서에 따릅니다.

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

인정된 답변이 매우 복잡하다는 점을 고려하면요.더 간단한 방법이 있습니다.내 것은 알렉산드루디쿠의 아나스워의 변형이다.64비트 윈도에서는 32비트 어플리케이션이 프로그램파일(x86)에 설치되어 있기 때문에 환경변수를 사용하여 해당 폴더가 존재하는지 확인할 수 있습니다(다른 현지화를 보완하기 위해).

예.

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

이것은 나에게 더 빠르고 간단하다.OS 버전에 따라 폴더 아래의 특정 경로에도 액세스하고 싶습니다.

이 질문은 에 대한 것입니다.NET 2.0은 아직 구글 검색에서 검색되고 있으며, 그 이후 아무도 그것에 대해 언급하지 않았다.NET 표준 1.1 /NET core 1.0에서는 CPU 아키텍처를 보다 잘 알 수 있습니다.

System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture

이것은 이론적으로 x64와 Arm64를 구별할 수 있을 것입니다만, 직접 테스트해 본 것은 아닙니다.

메뉴얼을 참조해 주세요.

VB 코드는 죄송합니다.NET. 단, C#에의 포트는 간단합니다.Windows 7, x 64 에서는 정상적으로 동작합니다.Net Framework 4.8:

Dim r As String = ""
Using searcher As ManagementObjectSearcher = New System.Management.ManagementObjectSearcher("SELECT * FROM Win32_OperatingSystem")
    Dim Information As ManagementObjectCollection = searcher.Get()
    If Information IsNot Nothing Then
        For Each obj As ManagementObject In Information
            r = obj("Caption").ToString() & _
            " - " & _
            obj("OSArchitecture").ToString() ' <--- !!! "64-bit" shown here
        Next
    End If
    MessageBox.Show(r)
End Using

즐기세요;-)

Function Is64Bit() As Boolean

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

End Function

"C:"가 있는지 확인해 보세요.\Program Files (x86)" 가 존재합니다.그렇지 않은 경우 32비트 OS를 사용하고 있습니다.이 경우 OS는 64비트(Windows Vista 또는 Windows 7)입니다.간단해 보이는데...

사용방법:

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:\.

언급URL : https://stackoverflow.com/questions/336633/how-to-detect-windows-64-bit-platform-with-net