L'identification de l'architecture du PROCESSEUR de type à l'aide de C#

Je veux vérifier quel est le PROCESSEUR de l'architecture est l'utilisateur en cours d'exécution, est-il
i386 ou 64 ou AMD64. Je veux le faire en C#.
Je sais que je peux essayer de WMI ou de Registre. Est-il un autre moyen en dehors de ces deux?
Mon projet objectifs .NET 2.0!

InformationsquelleAutor Anirudh Goel | 2009-04-20

architecture c#cpu identify

26

Vous pouvez également essayer (ne fonctionne que si elle n'est pas manipulée):
```
System.Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE")
```
- que faire si elle ne l'est pas?
- Pas jeu va à "manipulé" cas (au moins sur Vista, c'est le cas par défaut). Je l'ai proposé comme une alternative, pas forcément de la meilleure façon.
- Je suis sur AMD64 et Vista 64 bits et en regardant les variables dans la fenêtre de la console je vois AMD64 pour PROCESSOR_ARCHITECTURE, MAIS l'exécution de mes tests unitaires à l'aide de ReSharper je vois "x86" est revenu. Probablement OK si le test s'exécute en mode 32 bits, MAIS j'utilise ce résultat pour décider de la façon de lancer un autre fichier exécutable et de choisir sa version 32 bits qui refuse de démarrer sur le système d'exploitation 64 bits.
- Cela ne devrait PAS être utilisé pour détecter l'architecture du processeur de la machine. Il peut être utilisé pour détecter l'architecture du programme est en cours d'exécution sur. Si vous voulez vérifier pour voir si l'OS est en 64 bits, vous devez utiliser d'autres méthodes comme WMI. Cependant, l'OP est explicitement mentionné qu'il veut quelque chose d'autre.
- attention: la valeur de retour dépend de la façon dont le processus appelant a été compilé (x86, x64, AnyCPU)! la solution est de passer un deuxième paramètre: Système.De l'environnement.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE", EnvironmentVariableTarget.De la Machine) voir aussi stackoverflow.com/a/1739055/1468842
InformationsquelleAutor Mehrdad Afshari
22

Ce qui m'a amené ici est de vérifier pour un 32 vs 64 bits de l'OS. la cote la plus élevée réponse est à la recherche à la processus Actuel. Après ne pas trouver de réponse, j'ai trouvé le paramètre suivant. Espérons que cela fonctionne pour vous.
```
bool is64 = System.Environment.Is64BitOperatingSystem
```
- Pris en charge uniquement dans .NET Framework 4+
- Désolé de relancer un vieux thread, mais comme un conseil pour un futur lecteur: depuis un processus 32 bits peut heureusement s'exécuter sur un système d'exploitation 64 bits, System.Environment.Is64BitProcess était plus utile dans mon cas (ensemble de la PATH variable pour le "corriger" sqlite3.dll basé sur l'architecture). Le système d'exploitation était en effet 64 bits dans mon cas, mais à cause d'une autre bibliothèque, j'ai dû compiler mon application 32 bits.
- Is64BitProcess n'apparaît pas au moins jusqu'à la version 4. Pour n'importe quelle version, je pense que IntPtr.La taille est la solution la plus élégante; j'ai enveloppé d'un ternaire expression autour de lui dans le code qui m'a amené à cette page.
InformationsquelleAutor Zak

Voici un morceau de code qui semble fonctionner (basé sur le 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 :-)
        }
    }

avec

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

Note ce code de réutilisation de l'existant du CLR ProcessorArchitecture enum, et prend en charge .NET framework 2 et plus.

Merci cela fonctionne très bien... Que j'attends le Type de Machine pas le type de système d'exploitation.
Simon, c'est de loin le plus mince de la solution proposée. Tout le monde qui a peur de la Plate-forme Invoquer de passer par-dessus; ce n'est pas (normalement) à la morsure!
Gardez à l'esprit, les docs pour SYSTEM_INFO utilisation DWORD et WORD qui sont à la fois non signé. Tout dans votre structure est signé.. cela pourrait causer des problèmes si vous utilisez d'autres membres de cette structure.

InformationsquelleAutor Simon Mourier

6

Win32_Processor Classe WMI va faire le travail. Utilisation MgmtClassGen.exe pour générer fortement typées wrappers.
- C'est probablement la meilleure réponse à la question.
- Cela m'a beaucoup aidé! merci et +1!
- comment est la classe Win32_Processor censé aider? si vous parliez de OSArchitecture, alors cette propriété n'est pas disponible sur la plupart des versions de Windows, à seulement quelques versions les plus récentes en charge.
InformationsquelleAutor Anton Gogolev
5

Enfin les plus brefs astuce pour résoudre la plate-forme/processeur d'architecture en cours d'exécution runtime CLR en C# est:
```
PortableExecutableKinds peKind;
ImageFileMachine machine;
typeof(object).Module.GetPEKind(out peKind, out machine);
```
Ici Le Module.GetPEKind retourne un ImageFileMachine énumération, qui existe depuis .NET v2:
```
public enum ImageFileMachine
{
    I386    = 0x014C,
    IA64    = 0x0200,
    AMD64   = 0x8664,
    ARM     = 0x01C4    //new in .NET 4.5
}
```
Pourquoi ne pas utiliser new AssemblyName(fullName) ou typeof(object).Assembly.GetName()?

Eh bien, il est ce HACK commentaire ASP.NET MVC code source (depuis la 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);
}
```
Voir qu'ils utilisent certains des trucs pour eux-mêmes. Malheureusement, la AssemblyName constructeur n'a pas réglé le ProcessorArchitecture champ de façon appropriée, c'est juste None pour toute nouvelle AssemblyName.

Donc, pour les futurs lecteurs, laissez-moi vous recommandons d'utiliser ce vilain GetPEKind avec ImageFileMachine!

Notes:
- Renvoie le courant architecture d'exécution, pas le système sous-jacent de l'architecture!
  
  Cela dit, la seule exception est qu'un I386 exécution peuvent s'exécuter sur un système AMD64.
- Testé sur mono/ubuntu 14.04/AMD64 et .NET/Win7/I386.
InformationsquelleAutor metadings
4

Je sais que cette question est du passé, mais à partir de 2017, il existe maintenant une méthode simple pour connaître l'architecture de la procédure en cours, en .net standard :
```
System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture
```
La valeur retournée est l'un des X86, X64, ARM, ARM64 et donne à l'architecture du processus, il est en cours d'exécution. OSArchitecture renvoie l'architecture du système d'exploitation installé à la place.

Des liens vers les docs (assez inutile si...):

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

L'Architecture de l'énumération:
https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.architecture?view=netstandard-1.4
- Cela ne fonctionne pas pour x86 .NET applications en cours d'exécution sur ARM64: stackoverflow.com/questions/54456140/...
InformationsquelleAutor cube45
1

Peut-être cette CodeProject article peut aider? Il utilise le ManagementObjectSearcher dans le Système.La gestion de l'espace de noms pour rechercher du matériel info.

InformationsquelleAutor Erik Hellström
1

En fonction de pourquoi vous voulez savoir, vous trouverez peut-être que la vérification de la taille de la IntPtr structure est le moyen le plus facile.
- J'aime la façon dont Anonymous Coward pense!
InformationsquelleAutor Anonymous Coward
0

Vous pourriez demander à l'utilisateur, peut-être?

Juste une blague bien sûr... je pense que WMI est ce que vous pouvez utiliser pour cela. Mais peut-être qu'il y a une autre manière?

Si vous allez pour WMI puis LinqToWmi pourrait leur être utile. J'ai essayé une fois, et il semblait assez simple =) -> http://www.codeplex.com/linq2wmi

InformationsquelleAutor Svish
0

Je crois que vous devriez éviter les ballonnements comme WMI et LINQ.. et vous aurez finalement, pour obtenir plus d'info comme vous allez le long, dont aucun n'est satisfait par pléthorique des api et des cadres.

Il suffit d'invoquer une dll que les appels et les extraits de CPUID info. C++/CLI ou pinvoke serait de faire et d'obtenir toutes les informations dont vous avez besoin sur le vendeur. Vous devez d'abord voir si l'enseignement est pris en charge (99% du temps c'est).

Pour obtenir rapidement vers le haut et en cours d'exécution est de vérifier le site d'intel pour wincpuid de l'échantillon et de l'extrait de la pièce de cpuid.h à partir de là. Il y a que 2 vendeurs et l'on est bon avec la latence de la mémoire et de l'autre ne l'est pas (comme native vs code managé). Ainsi, vous aurez des problèmes avec Mono sur d'autres architectures, etc (qui n'a pas d'ailleurs). Comme pour x64 vous le savez déjà ou tout simplement obtenir le corflags (son et déjà de tuer votre client disque dur avec .La distribution de moustiquaires )..

(http://software.intel.com/en-us/articles/api-detects-ia-32-and-x64-platform-cpu-characteristics/)
- Je vous remercie déjà pour l'expression de la pensée que j'ai eu (ce qui a suscité un gémissement) quand j'ai lu la suggestion de l'aide de WMI.
- Votre lien intel.com est maintenant mort.
InformationsquelleAutor rama-jka toti
0

Ce qui semble le plus simple pour moi:
```
System.Environment.Is64BitOperatingSystem
```
- il est disponible en .NET 4.0, alors que la question est à propos .NET 2.0
InformationsquelleAutor dpminusa

Comment à ce sujet?

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

Cependant case *.Arm: n'est pas encore testé.

InformationsquelleAutor kenjiuno

-4

Voici ce que j'ai fait:
```
public static bool Isx86()
{
    return (Environment.ExpandEnvironmentVariables("%ProgramFiles(x86)%").Length == 0);
}
```
Si vous êtes en 64 bits architecture, vous aurez deux fichier de programme des variables d'environnement. Si vous êtes sur x86, vous aurez seulement une.
- Laid, si tout ce qui vous intéresse est de 32 bits vs 64 bits aka x86 vs x64 suffit d'utiliser la suite de la BCL de la propriété.Is64BitOperatingSystem
InformationsquelleAutor Brett

Vous devez vous connecter pour publier un commentaire.