.NET 2.0 C＃アプリケーションでは、次のコードを使用してオペレーティングシステムプラットフォームを検出します。
string os_platform = System.Environment.OSVersion.Platform.ToString();
これは「Win32NT」を返します。問題は、WindowsVista64ビットで実行している場合でも「Win32NT」を返すことです。
正しいプラットフォーム（32ビットまたは64ビット）を知る他の方法はありますか？
Windows 64ビットで32ビットアプリケーションとして実行する場合も、64ビットを検出する必要があることに注意してください。
.NET 4 には、環境クラスにIs64BitProcessとIs64BitOperatingSystemの 2 つの新しいプロパティがあります。興味深いことに、Reflector を使用すると、mscorlib の 32 ビット バージョンと 64 ビット バージョンで実装が異なることがわかります。32 ビット バージョンは、Is64BitProcess に対して false を返し、Is64BitOperatingSystem に対して P/Invoke を介して IsWow64Process を呼び出します。64 ビット バージョンは、両方に対して true を返すだけです。
更新: Joel Coehoorn などが示唆しているように、.NET Framework 4.0 以降では、Environment.Is64BitOperatingSystem.
64 ビット Windows 上の 32 ビット .NET Framework 2.0 で実行している場合、IntPtr.Size は正しい値を返しません (32 ビットが返されます)。
Microsoft の Raymond Chen が説明しているように、最初に 64 ビット プロセスで実行されているかどうかを確認する必要があります (.NET では、IntPtr.Size を確認することで確認できると思います)。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
Environment.Is64BitOperatingSystem プロパティ(MSDN)を参照してください。
完全な答えはこれです（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ビットプロセスが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ビット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);
}
クリス・ユエンのブログより
C# .Net 4.0 では、2 つの新しい環境プロパティ Environment.Is64BitOperatingSystem が導入されました。Environment.Is64BitProcess;
これらの両方のプロパティを使用する場合は注意してください。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
}
注：<Prefer32Bit>true</Prefer32Bit>これは非常に直接的であり、プログラムが32ビットプロセスとして（プロジェクト設定などで）実行を強制しない場合にのみ、64ビットで正しく機能し
@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: Detect Process Bitnessを参照してください。
私はこれを行う必要がありますが、管理者としてリモートで実行できるようにする必要もあります。どちらの場合でも、これは私にとって非常にうまく機能しているようです:
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);
}
すべて問題ありませんが、これは以下からも機能するはずenvです：
PROCESSOR_ARCHITECTURE=x86
..
PROCESSOR_ARCHITECTURE=AMD64
簡単すぎるかもしれません;-)
これが、システムのプラットフォームとプロセスを確認する最良の方法であることがわかりました。
bool 64BitSystem = Environment.Is64BitOperatingSystem;
bool 64BitProcess = Environment.Is64BitProcess;
最初のプロパティは、64 ビット システムの場合は true、32 ビット システムの場合は false を返します。2 番目のプロパティは、64 ビット プロセスの場合は true、32 ビット プロセスの場合は false を返します。
これら 2 つのプロパティが必要なのは、64 ビット システムで 32 ビット プロセスを実行できるためです。そのため、システムとプロセスの両方を確認する必要があります。
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;
}
この質問は .NET 2.0 に関するものですが、それでも Google 検索に出てきます。.NET 標準 1.1 / .NET コア 1.0 以降、CPU アーキテクチャを知るためのより良い方法があることについて誰も言及していません。
System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture
私自身はテストしていませんが、理論的には x64 と Arm64 を区別できるはずです。
ドキュメントを参照してください。
「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:\。
次のバージョンを使用します。
public static bool Is64BitSystem()
{
if (Directory.Exists(Environment.GetEnvironmentVariable("Program Files (x86)"))) return true;
else return false;
}