Identificazione del tipo di architettura CPU utilizzando C#

Question

Voglio verificare quale architettura CPU è l'utente in esecuzione, è i386 o X64 o AMD64. Voglio farlo in C#. So di poter provare WMI o registro. C'è qualche altro modo oltre a questi due? Il mio progetto si rivolge a .NET 2.0!

Answer 1

Si potrebbe anche provare (funziona solo se non è manipolato):

System.Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE") 

Answer 2

Si potrebbe chiedere all'utente forse?

Sto scherzando ovviamente ... Penso che WMI sia quello che useresti per quello. Ma forse c'è anche un altro modo?

Se si utilizza WMI, LinqToWmi potrebbe essere utile. L'ho provato una volta, e sembrava abbastanza diretto =) ->http://www.codeplex.com/linq2wmi

Answer 3

Win32_Processor Classe WMI farà il lavoro. Utilizzare MgmtClassGen.exe per generare wrapper fortemente tipizzati.

Answer 4

Forse this articolo CodeProject potrebbe aiutare? Utilizza ManagementObjectSearcher nello spazio dei nomi System.Management per cercare informazioni sull'hardware.

Answer 5

Credo che dovresti evitare pesanti rigonfiamenti come WMI e LINQ .. e alla fine dovrai ottenere più informazioni mentre prosegui, nessuna delle quali è soddisfatta da gonfiori di apis e framework.

Basta richiamare una DLL che chiama ed estrae informazioni CPUID. C++/CLI o pinvoke farebbero e ottenere tutte le informazioni necessarie sul venditore. Per prima cosa è necessario verificare se l'istruzione è supportata (il 99% delle volte lo è).

Per essere subito operativi è necessario controllare il sito Intel per il campione wincpuid ed estrarre il pezzo da cpuid.h da lì. Ci sono solo 2 fornitori e uno è buono con la latenza della memoria e l'altro non lo è (come il codice nativo vs gestito). Quindi avrai problemi con Mono su altre architetture ecc (chi non btw). Per quanto riguarda i 64 che già lo sappia o solo ottenere il corflags (la sua già e uccidendo sul disco rigido del cliente con la distribuzione .NET lì) ..

(http://software.intel.com/en-us/articles/api-detects-ia-32-and-x64-platform-cpu-characteristics/)

Answer 6

Ecco quello che ho fatto:

public static bool Isx86() 
{ 
    return (Environment.ExpandEnvironmentVariables("%ProgramFiles(x86)%").Length == 0); 
} 

Se sei in architettura a 64 bit avrai due variabili di env del file di programma. Se sei su x86, ne avrai solo uno.

Answer 7

Questo sembra il più semplice per me:

System.Environment.Is64BitOperatingSystem 

Answer 8

Ciò che mi ha portato qui è il controllo per un sistema operativo a 32 vs 64 bit. la risposta con il punteggio più alto sta osservando l'impostazione per il processo corrente . Dopo aver trovato una risposta, ho trovato la seguente impostazione. Spero che questo funzioni per te.

bool is64 = System.Environment.Is64BitOperatingSystem 

Answer 9

Ecco un pezzo di codice che sembra funzionare (sulla base di P/Invoke):

public static ProcessorArchitecture GetProcessorArchitecture() 
    { 
     SYSTEM_INFO si = new SYSTEM_INFO(); 
     GetNativeSystemInfo(ref si); 
     switch (si.wProcessorArchitecture) 
     { 
      case PROCESSOR_ARCHITECTURE_AMD64: 
       return ProcessorArchitecture.Amd64; 

      case PROCESSOR_ARCHITECTURE_IA64: 
       return ProcessorArchitecture.IA64; 

      case PROCESSOR_ARCHITECTURE_INTEL: 
       return ProcessorArchitecture.X86; 

      default: 
       return ProcessorArchitecture.None; // that's weird :-) 
     } 
    } 

con

[DllImport("kernel32.dll")] 
    private static extern void GetNativeSystemInfo(ref SYSTEM_INFO lpSystemInfo); 

    private const int PROCESSOR_ARCHITECTURE_AMD64 = 9; 
    private const int PROCESSOR_ARCHITECTURE_IA64 = 6; 
    private const int PROCESSOR_ARCHITECTURE_INTEL = 0; 

    [StructLayout(LayoutKind.Sequential)] 
    private struct SYSTEM_INFO 
    { 
     public short wProcessorArchitecture; 
     public short wReserved; 
     public int dwPageSize; 
     public IntPtr lpMinimumApplicationAddress; 
     public IntPtr lpMaximumApplicationAddress; 
     public IntPtr dwActiveProcessorMask; 
     public int dwNumberOfProcessors; 
     public int dwProcessorType; 
     public int dwAllocationGranularity; 
     public short wProcessorLevel; 
     public short wProcessorRevision; 
    } 

Nota questo codice riutilizza ProcessorArchitecture enum del CLR esistente, e supporta .NET Framework 2 e versioni successive.

Answer 10

Infine il trucco più breve per risolvere l'architettura della piattaforma/processore per l'attuale fase di esecuzione in esecuzione CLR in C# è:

PortableExecutableKinds peKind; 
ImageFileMachine machine; 
typeof(object).Module.GetPEKind(out peKind, out machine); 

Qui Module.GetPEKind restituisce un ImageFileMachine enumerazione, che esiste dal .NET v2:

public enum ImageFileMachine 
{ 
    I386 = 0x014C, 
    IA64 = 0x0200, 
    AMD64 = 0x8664, 
    ARM  = 0x01C4 // new in .NET 4.5 
} 

Perché non utilizzare new AssemblyName(fullName) o typeof(object).Assembly.GetName()?
Beh c'è questo HACK commento nel codice sorgente ASP.NET MVC (dal 1,0):

private static string GetMvcVersionString() { 
    // DevDiv 216459: 
    // This code originally used Assembly.GetName(), but that requires FileIOPermission, which isn't granted in 
    // medium trust. However, Assembly.FullName *is* accessible in medium trust. 
    return new AssemblyName(typeof(MvcHttpHandler).Assembly.FullName).Version.ToString(2); 
} 

Vedi usano alcuni trucchi nascosti per se stessi. Purtroppo, il costruttore AssemblyName non imposta il campo ProcessorArchitecture in modo appropriato, è solo None per qualsiasi nuovo Nome Assembly.

Quindi, per i futuri lettori, ti consiglio di utilizzare quel brutto GetPEKind con ImageFileMachine!

Note:

• Questo restituisce la corrente in esecuzione architettura runtime, non l'architettura del sistema sottostante!
  Detto questo, l'unica eccezione è che un runtime I386 può essere eseguito su un sistema AMD64.
• Testato su mono/ubuntu 14.04/AMD64 e .NET/Win7/I386.

Answer 11

A seconda del motivo per cui lo si desidera, è possibile che verificare la dimensione della struttura IntPtr sia il modo più semplice.

Answer 12

So che questa domanda è dal passato, ma a partire dal 2017, v'è ora un metodo semplice per conoscere l'architettura del processo corrente, nella norma .net:

System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture 

Il valore restituito è uno di X86, X64, ARM, ARM64 e fornisce l'architettura del processo in cui è in esecuzione. OSArchitecture restituisce invece l'architettura del sistema operativo installato.

link ai documenti (abbastanza inutile se ...):

RuntimeInformation.ProcessArchitecture: https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.runtimeinformation.processarchitecture?view=netstandard-1.4

Architettura enumerazione: https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.architecture?view=netstandard-1.4

Answer 13

ne dici di questo?

switch (typeof(string).Assembly.GetName().ProcessorArchitecture) { 
    case System.Reflection.ProcessorArchitecture.X86: 
     break; 
    case System.Reflection.ProcessorArchitecture.Amd64: 
     break; 
    case System.Reflection.ProcessorArchitecture.Arm: 
     break; 
} 

Tuttavia case *.Arm: non è ancora testato.