.NET ile Windows 64 bit platformu nasıl algılanır?

Bir .NET 2.0 C # uygulamasında işletim sistemi platformunu algılamak için aşağıdaki kodu kullanıyorum:

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

Bu "Win32NT" döndürür. Sorun Windows Vista 64-bit üzerinde çalışırken bile "Win32NT" döndürüyor olmasıdır.

Doğru platformu (32 veya 64 bit) bilmek için başka bir yöntem var mı?

Ayrıca, Windows 64 bit'te 32 bit uygulama olarak çalıştırıldığında 64 bit algılaması gerektiğini unutmayın.

IntPtr.Size, 64 bit Windows'ta 32 bit .NET Framework 2.0'da çalışıyorsa doğru değeri döndürmez (32 bit döndürür).

Microsoft'un Raymond Chen'in açıkladığı gibi, önce 64 bitlik bir işlemde çalışıp çalışmadığınızı kontrol etmeniz gerekir (bence .NET'te IntPtr.Size'yi kontrol ederek bunu yapabilirsiniz) ve 32 bitlik bir işlemde çalışıyorsanız, Win API işlevini IsWow64Process çağırmak zorunda. Bu doğruysa, 64 bit Windows'ta 32 bit işlemde çalışıyorsunuz demektir.

Microsoft'tan Raymond Chen: 64-bit Windows üzerinde çalışıp çalışmadığınızı programlı olarak algılama

Çözümüm:

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 Ortam sınıfında Is64BitProcess ve Is64BitOperatingSystem olmak üzere iki yeni özelliğe sahiptir . İlginç bir şekilde, Reflector kullanıyorsanız, mscorlib'in 32 bit ve 64 bit sürümlerinde farklı uygulandığını görebilirsiniz. 32-bit sürüm Is64BitProcess için false döndürür ve Is64BitOperatingSystem için P / Invoke üzerinden IsWow64Process çağırır. 64-bit sürümü her ikisi için de true değerini döndürür.

.NET Framework 4.0 kullanıyorsanız , kolay:

Environment.Is64BitOperatingSystem

Bkz. Environment.Is64BitOperatingSystem Özelliği (MSDN).

Bu sadece yukarıda Bruno Lopez tarafından önerilenlerin bir uygulamasıdır, ancak Win2k + tüm WinXP hizmet paketleri üzerinde çalışır. Sadece diğer insanların elle yuvarlanmadığını düşündüm. (yorum olarak yayınlanırdı, ancak ben yeni bir kullanıcıyım!)

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

Tam cevap şudur (stefan-mg, ripper234 ve BobbyShaftoe'un cevabından alınmıştır):

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

Önce 64 bit işlemde olup olmadığınızı kontrol edin. Değilse, 32 bit işlemin bir Wow64Process olup olmadığını kontrol edin.

Microsoft bunun için bir kod örneği koydu:

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

Şöyle görünüyor:

    /// <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 sürümü de bulunmaktadır (uzak makineleri test etmek için).

PROCESSOR_ARCHITECTUREOrtam değişkenini de kontrol edebilirsiniz .

Ya mevcut değil ya da 32 bit Windows'ta "x86" olarak ayarlanmış.

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 blogundan

C # .Net 4.0 İki yeni ortam özelliği tanıttı Environment.Is64BitOperatingSystem; Environment.Is64BitProcess;

Her iki özelliği de kullanırken lütfen dikkatli olun. Windows 7 64 bit Makinede Test

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

En hızlı yol:

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

Not: Bu çok doğrudan bir işlemdir ve yalnızca program 32-bit bir işlem olarak yürütmeyi zorlamazsa (örneğin<Prefer32Bit>true</Prefer32Bit>proje ayarlarında)64-bit üzerinde düzgün çalışır.

Bunu dene:

Environment.Is64BitOperatingSystem

Environment.Is64BitProcess

@foobar: Haklısın, çok kolay;)

Vakaların% 99'unda, zayıf sistem yöneticisi geçmişine sahip geliştiriciler sonuçta Microsoft'un her zaman Windows'un numaralandırması için sağladığı gücü fark edemiyorlar.

Böyle bir noktaya geldiğinde sistem yöneticileri her zaman daha iyi ve daha basit kod yazacaklardır.

Bununla birlikte, dikkat edilmesi gereken bir şey, yapı yapılandırmasının bu ortam değişkeninin doğru sistemlerde doğru değerleri döndürmesi için AnyCPU olması gerekir :

System.Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE")

Bu, 32 bit Windows'ta "X86" ve 64 bit Windows'ta "AMD64" döndürür.

DotPeek kullanmak çerçevenin gerçekte nasıl çalıştığını görmeye yardımcı olur. Bunu göz önünde bulundurarak, işte şunları buldum:

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

Örnek kullanım:

EnvironmentHelper.Is64BitOperatingSystem();

Bu iki ortam değişkenini kullanın (sözde kod):

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
        }

NASIL: blog bitini saptamak için blog gönderisine bakın .

Bu kontrolü birçok işletim sisteminde başarıyla kullandım:

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

İşletim sisteminin dili ne olursa olsun bu klasöre her zaman "SysWOW64" adı verilir. Bu, .NET Framework 1.1 veya üstü için çalışır.

Bunu yapmak gerekir, ama aynı zamanda bir yönetici uzaktan yapmak mümkün olması gerekir, her iki durumda da bu benim için oldukça güzel görünüyor:

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

Bu, Microsoft'un http://1code.codeplex.com/SourceControl/changeset/view/39074#842775 adresindeki koduna dayanan bir çözümdür . Kolay kod kullanımı için genişletme yöntemleri kullanır.

Olası bazı kullanımlar aşağıda gösterilmiştir:

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

İşte bu sayfadan DllImport kullanarak C # doğrudan yaklaşım .

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

Ben takip kodunu kullanıyorum. Not: Bir AnyCPU projesi için yapılmıştır.

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

Bunu, sistemin platformunu ve sürecini kontrol etmenin en iyi yolu olarak buldum:

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

İlk özellik 64 bit sistem için true, 32 bit için false döndürür. İkinci özellik 64 bit işlem için true, 32 bit için false döndürür.

Bu iki özelliğe duyulan ihtiyaç, 64 bit sistemde 32 bit işlemleri çalıştırabilmenizdir, bu nedenle hem sistemi hem de işlemi kontrol etmeniz gerekecektir.

Her şey yolunda, ancak bu aynı zamanda aşağıdakilerden de çalışmalıdır env:

PROCESSOR_ARCHITECTURE=x86

..

PROCESSOR_ARCHITECTURE=AMD64

Çok kolay, belki ;-)

İşte bir Windows Yönetim Araçları (WMI) yaklaşımı:

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

Aşağıdaki kodu projenizdeki bir sınıfa ekleyin:

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

Şöyle kullanın:

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

Yüklü Windows mimarisini edinmek için bunu kullanın:

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

Kabul edilen cevabın çok karmaşık olduğu göz önüne alındığında. Daha basit yollar var. Benimki alexandrudicu'nun anaswer'ın bir çeşididir. 64 bit pencerelerin Program Dosyalarına (x86) 32 bit uygulamalar yüklediği göz önüne alındığında, ortam değişkenlerini kullanarak (farklı yerelleştirmeleri telafi etmek için) bu klasörün var olup olmadığını kontrol edebilirsiniz.

Örneğin

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

Bu benim için daha hızlı ve daha basit. OS sürümüne göre bu klasörün altındaki belirli bir yola erişmek istediğim göz önüne alındığında.

Zevk almak ;-)

Function Is64Bit() As Boolean

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

End Function

Sadece "C: \ Program Files (x86)" olup olmadığına bakın. Değilse, 32 bit işletim sistemindesiniz. Varsa, işletim sistemi 64 bittir (Windows Vista veya Windows 7). Yeterince basit görünüyor ...

Kullanırım:

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

Bu, bilgisayarınızda çeşitli yerlerde yüklü olması durumunda uygulamanızın başlatıldığı yolu alır. Ayrıca, C:\bilgisayarların% 99,9'u Windows yüklü olduğu için genel yolu yapabilirsiniz C:\.

Aşağıdakilerin bir sürümünü kullanıyorum:

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