c# - .NET के साथ विंडोज 64-बिट प्लेटफॉर्म का पता कैसे लगाएं?




windows 64bit (20)

एक .NET 2.0 सी # अनुप्रयोग में मैं ऑपरेटिंग सिस्टम प्लेटफ़ॉर्म का पता लगाने के लिए निम्न कोड का उपयोग करता हूं:

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

यह "Win32NT" देता है। समस्या यह है कि यह Windows Vista 64-बिट पर चलते समय भी "Win32NT" देता है।

सही मंच (32 या 64 बिट) जानने के लिए कोई और तरीका है?

ध्यान दें कि Windows 64 बिट पर 32 बिट अनुप्रयोग के रूप में चलाने पर इसे 64 बिट का पता लगाना चाहिए।


.NET 4 में पर्यावरण वर्ग, Is64BitProcess और Is64BitOperatingSystem में दो नई गुण हैं। दिलचस्प बात यह है कि यदि आप परावर्तक का उपयोग करते हैं तो आप देख सकते हैं कि उन्हें mscorlib के 32-बिट और 64-बिट संस्करणों में अलग-अलग कार्यान्वित किया गया है। 32-बिट संस्करण Is64BitProcess के लिए झूठा रिटर्न देता है और Is64BitOperatingSystem के लिए P / Invoke के माध्यम से IsWow64Process को कॉल करता है। 64-बिट संस्करण दोनों के लिए सच है।


64-बिट विंडोज़ पर 32-बिट .NET Framework 2.0 में चलने पर IntPtr.Size सही मान वापस नहीं करेगा (यह 32-बिट वापस आ जाएगा)।

चूंकि माइक्रोसॉफ्ट के रेमंड चेन का वर्णन है, आपको पहले जांचना होगा कि क्या 64-बिट प्रक्रिया में चल रहा है (मुझे लगता है कि .NET में आप IntPtr.Size की जांच करके ऐसा कर सकते हैं), और यदि आप 32-बिट प्रक्रिया में चल रहे हैं, तो भी आप Win API फ़ंक्शन IsWow64Process को कॉल करना होगा। यदि यह सच हो जाता है, तो आप 64-बिट विंडोज़ पर 32-बिट प्रक्रिया में चल रहे हैं।

माइक्रोसॉफ्ट के रेमंड चेन: प्रोग्रामेटिक रूप से कैसे पता लगाया जाए कि आप 64-बिट विंडोज़ पर चल रहे हैं या नहीं

मेरा समाधान:

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

अपनी परियोजना में एक वर्ग में निम्नलिखित कोड शामिल करें:

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

आप PROCESSOR_ARCHITECTURE पर्यावरण परिवर्तक की जांच भी कर सकते हैं।

यह या तो मौजूद नहीं है या 32-बिट विंडोज़ पर "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);
}

इसे इस्तेमाल करे:

Environment.Is64BitOperatingSystem

Environment.Is64BitProcess

का आनंद लें ;-)

Function Is64Bit() As Boolean

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

End Function

पूरा जवाब यह है (स्टीफन-एमजी, रिपर 234 और बॉबी शाफ्टो के जवाब दोनों से लिया गया है):

    [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 है या नहीं।


बस देखें कि "सी: \ प्रोग्राम फ़ाइलें (x86)" मौजूद है या नहीं। यदि नहीं, तो आप 32 बिट ओएस पर हैं। यदि ऐसा होता है, तो ओएस 64 बिट (विंडोज विस्टा या विंडोज 7) है। यह काफी आसान लगता है ...


मुझे ऐसा करने की ज़रूरत है, लेकिन मुझे व्यवस्थापक के रूप में इसे दूरस्थ रूप से करने की भी आवश्यकता है, या तो यह मेरे लिए काफी अच्छी तरह से काम करता है:

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

मैं उपयोग करता हूं:

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:\ में स्थापित है।


मैं फॉलोइन कोड का उपयोग कर रहा हूँ। नोट: यह किसी भी एसीसीपीयू परियोजना के लिए बनाया गया है।

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

मैंने कई ऑपरेटिंग सिस्टम पर सफलता के साथ इस चेक का इस्तेमाल किया:

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

इस फ़ोल्डर को हमेशा "SysWOW64" नाम दिया जाता है, ऑपरेटिंग सिस्टम की भाषा से कोई फर्क नहीं पड़ता। यह .NET Framework 1.1 या ऊपर के लिए काम करता है।



यह देखते हुए कि स्वीकृत उत्तर बहुत जटिल है। सरल तरीके हैं। मेरा अलेक्ज़ेंडरुडु के एनासर का एक बदलाव है। यह देखते हुए कि 64-बिट विंडोज़ प्रोग्राम फ़ाइलों (x86) में 32-बिट अनुप्रयोग स्थापित करते हैं, आप यह जांच सकते हैं कि वह वातावरण मौजूद है या नहीं, पर्यावरण चर का उपयोग करके (विभिन्न स्थानीयकरण के लिए तैयार करने के लिए)

जैसे

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

यह मेरे लिए तेज़ और सरल है। यह देखते हुए कि मैं ओएस संस्करण के आधार पर उस फ़ोल्डर के तहत एक विशिष्ट पथ तक पहुंच बनाना चाहता हूं।


यह माइक्रोसॉफ्ट के कोड पर आधारित एक समाधान है 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);  
}

यहां एक विंडोज मैनेजमेंट इंस्ट्रुमेंटेशन (डब्लूएमआई) दृष्टिकोण है:

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:

सबसे त्वरित तरीका:

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

नोट: यह बहुत प्रत्यक्ष है।


स्थापित विंडोज आर्किटेक्चर प्राप्त करने के लिए इसका इस्तेमाल करें:

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

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

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




platform-detection