एक में नेट 2.0 सी # आवेदन मैं ऑपरेटिंग सिस्टम मंच का पता लगाने के लिए निम्न कोड का उपयोग करें:
string os_platform = System.Environment.OSVersion.Platform.ToString();यह "Win32NT" देता है। समस्या यह है कि यह विंडोज़ विस्टा 64-बिट पर चलने पर भी "Win32NT" देता है।
क्या सही प्लेटफॉर्म (32 या 64 बिट) को जानने के लिए कोई अन्य तरीका है?
ध्यान दें कि विंडोज 64 बिट पर 32 बिट एप्लिकेशन के रूप में चलने पर इसे 64 बिट का भी पता लगाना चाहिए।
जवाबों:
यदि 64-बिट विंडोज पर 32-बिट .NET फ्रेमवर्क 2.0 में चल रहा है (यह 32-बिट लौटेगा) तो इंटप्रेट.साइज सही मान नहीं लौटाएगा।
जैसा कि Microsoft के रेमंड चेन ने वर्णन किया है, आपको पहले जांचना होगा कि क्या 64-बिट प्रक्रिया में चल रहा है (मुझे लगता है कि .NET में आप IntPtr.Size की जांच करके ऐसा कर सकते हैं), और यदि आप 32-बिट प्रक्रिया में चल रहे हैं, तो आप अभी भी विन एपीआई फ़ंक्शन 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;
}
}System.Environment.Is64BitOperatingSystem। क्या आप इसे अपने उत्तर में संपादित कर सकते हैं, या मुझे अपने उत्तर में संपादित करने की अनुमति दे सकते हैं?
.NET 4 में पर्यावरण वर्ग, Is64BitProcess और Is64BitOperatingSystem में दो नए गुण हैं । दिलचस्प बात यह है कि यदि आप रिफ्लेक्टर का उपयोग करते हैं, तो आप देख सकते हैं कि उन्हें एमएसकोर्लिब के 32-बिट और 64-बिट संस्करणों में अलग-अलग कार्यान्वित किया गया है। 32-बिट संस्करण Is64BitProcess के लिए गलत है और Is64BitOperatingSystem के लिए P / Invoke के माध्यम से IsWow64Process को कॉल करता है। 64-बिट संस्करण दोनों के लिए सही है।
if (IntPtr.Size == 8) return true; if(!DoesWin32MethodExist(...,"IsWow64Process")) return false; return IsWow64Process(GetCurrentProcess());(छद्म कोड)
Is64BitProcessऔर Is64BitOperatingSystem(संस्करण 2.0 के लिए लिंक) पढ़ सकते हैं ।
यदि आप .NET फ्रेमवर्क 4.0 का उपयोग कर रहे हैं , तो यह आसान है:
Environment.Is64BitOperatingSystemपर्यावरण देखें। S64BitOperatingSystem Property (MSDN)।
यह केवल ब्रूनो लोपेज़ द्वारा सुझाए गए कार्यों का एक कार्यान्वयन है, लेकिन Win2k + सभी 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;
}पूर्ण उत्तर यह है (दोनों स्टीफन-एमजी, ripper234 और बॉबी शेफेटो के उत्तर से लिया गया है):
[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 है।
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-बिट विंडोज पर "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);
}prefer 32-bitसाथ के Any CPUरूप में कॉन्फ़िगर किया जाता है, Platform Targetतो आप प्राप्त करेंगे x86, लेकिन यदि आप Prefer 32-bitइसे अनचेक करते हैं तो आप प्राप्त करेंगे AMD64।
Chriz Yuen ब्लॉग से
C # .net 4.0 दो नए पर्यावरण संपत्ति का परिचय दिया गया। Environment.Is64BitProcess;
कृपया सावधान रहें जब आप इन दोनों संपत्ति का उपयोग करते हैं। विंडोज 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
} नोट: यह बहुत सीधा है और केवल 64-बिट पर सही ढंग से काम करता है, अगर प्रोग्राम निष्पादन को 32-बिट प्रक्रिया (जैसे<Prefer32Bit>true</Prefer32Bit>प्रोजेक्ट सेटिंग्स केमाध्यम से) केरूप में लागू नहीं करता है।
इसे इस्तेमाल करे:
Environment.Is64BitOperatingSystem
Environment.Is64BitProcess@foobar: आप सही हैं, यह बहुत आसान है;)
99% मामलों में, कमजोर सिस्टम व्यवस्थापक पृष्ठभूमि वाले डेवलपर्स अंततः उस शक्ति को महसूस करने में विफल होते हैं जो Microsoft ने किसी को भी विंडोज को एन्यूमरेट करने के लिए हमेशा प्रदान किया है।
सिस्टम प्रशासक हमेशा इस तरह के बिंदु पर आने पर बेहतर और सरल कोड लिखेंगे।
फिर भी, एक बात ध्यान दें, कॉन्फ़िगरेशन का निर्माण इस वातावरण चर के लिए AnyCPU होना चाहिए ताकि सही सिस्टम पर सही मान लौट सकें :
System.Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE")यह 32-बिट विंडोज पर "X86", और 64-बिट विंडोज पर "एएमडी 64" लौटाएगा।
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();इन दो पर्यावरण चर (छद्म कोड) का उपयोग करें:
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 फ्रेमवर्क 1.1 या इसके बाद के संस्करण के लिए काम करता है।
SysWOW64एक पर %windir%एक 32 बिट ओएस पर? एक फ़ोल्डर की उपस्थिति का अर्थ है कि: फ़ोल्डर मौजूद है।
मुझे ऐसा करने की आवश्यकता है, लेकिन मुझे एक प्रशासक के रूप में इसे दूरस्थ रूप से सक्षम करने की आवश्यकता है, या तो यह मामला मेरे लिए काफी अच्छी तरह से काम करता है:
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;
} IsWow64Processहोता है , क्योंकि इसका कोई अस्तित्व नहीं है।
मैं फॉलोइन कोड का उपयोग कर रहा हूं। नोट: यह एक 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-बिट सिस्टम के लिए सही है, और 32-बिट के लिए झूठी है। दूसरी संपत्ति 64-बिट प्रक्रिया के लिए सही है, और 32-बिट के लिए गलत है।
इन दो गुणों की आवश्यकता इसलिए है क्योंकि आप 64-बिट सिस्टम पर 32-बिट प्रक्रियाएं चला सकते हैं, इसलिए आपको सिस्टम और प्रक्रिया दोनों के लिए जांचना होगा।
सब ठीक है, लेकिन इस से भी काम करना चाहिए env:
PROCESSOR_ARCHITECTURE=x86..
PROCESSOR_ARCHITECTURE=AMD64बहुत आसान, शायद ;-)
यहाँ एक विंडोज मैनेजमेंट इंस्ट्रूमेंटेशन है (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.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();
}
}
}अपनी परियोजना में एक वर्ग में निम्नलिखित कोड शामिल करें:
[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";स्थापित विंडोज आर्किटेक्चर पाने के लिए इसका उपयोग करें:
string getOSArchitecture()
{
string architectureStr;
if (Directory.Exists(Environment.GetFolderPath(
Environment.SpecialFolder.ProgramFilesX86))) {
architectureStr ="64-bit";
}
else {
architectureStr = "32-bit";
}
return architectureStr;
}यह देखते हुए कि स्वीकृत उत्तर बहुत जटिल है। सरल तरीके हैं। मेरा अलेक्जेंड्रुडिकु के एसेवेर का एक रूपांतर है। यह देखते हुए कि 64-बिट विंडोज़ प्रोग्राम फाइल्स (x86) में 32-बिट एप्लिकेशन इंस्टॉल करती हैं, आप जाँच सकते हैं कि क्या वह फ़ोल्डर मौजूद है, पर्यावरण चर का उपयोग करके (विभिन्न स्थानीयकरणों के लिए)
जैसे
private bool Is64BitSystem
{
get
{
return Directory.Exists(Environment.ExpandEnvironmentVariables(@"%PROGRAMFILES(X86)%"));
}
}यह मेरे लिए तेज और सरल है। यह देखते हुए कि मैं ओएस संस्करण पर आधारित उस फ़ोल्डर के तहत एक विशिष्ट पथ का उपयोग करना चाहता हूं।
का आनंद लें ;-)
Function Is64Bit() As Boolean
Return My.Computer.FileSystem.SpecialDirectories.ProgramFiles.Contains("Program Files (x86)")
End Functionबस देखें कि क्या "C: \ Program Files (x86)" मौजूद है। यदि नहीं, तो आप 32 बिट OS पर हैं। यदि ऐसा होता है, तो ओएस 64 बिट (विंडोज विस्टा या विंडोज 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% कंप्यूटरों में विंडोज स्थापित है C:\।
मैं निम्नलिखित के एक संस्करण का उपयोग करता हूं:
public static bool Is64BitSystem()
{
if (Directory.Exists(Environment.GetEnvironmentVariable("Program Files (x86)"))) return true;
else return false;
}