Wie kann ich feststellen, ob eine .NET-Assembly für x86 oder x64 erstellt wurde?

Question

Ich habe eine willkürliche Liste von .NET-Assemblies.

Ich muss programmatisch prüfen, ob jede DLL für x86 (im Gegensatz zu x64 oder Any CPU) erstellt wurde. Ist dies möglich?

Answer 1

Blick auf System.Reflection.AssemblyName.GetAssemblyName(string assemblyFile)

Sie können die Assembly-Metadaten anhand der zurückgegebenen AssemblyName-Instanz untersuchen:

Verwendung von PowerShell :

\[36\] C:\\> \[reflection.assemblyname\]::GetAssemblyName("${pwd}\\Microsoft.GLEE.dll") | fl

Name                  : Microsoft.GLEE
Version               : 1.0.0.0
CultureInfo           :
CodeBase              : file:///C:/projects/powershell/BuildAnalyzer/...
EscapedCodeBase       : file:///C:/projects/powershell/BuildAnalyzer/...
**ProcessorArchitecture : MSIL**
Flags                 : PublicKey
HashAlgorithm         : SHA1
VersionCompatibility  : SameMachine
KeyPair               :
FullName              : Microsoft.GLEE, Version=1.0.0.0, Culture=neut... 

Hier, ProzessorArchitektur identifiziert die Zielplattform.

• Amd64 : Ein 64-Bit-Prozessor, der auf der x64-Architektur basiert.
• Arm : Ein ARM-Prozessor.
• IA64 : Nur ein 64-Bit Intel Itanium-Prozessor.
• MSIL : Neutral in Bezug auf Prozessor und Bits pro Wort.
• X86 : Ein 32-Bit-Intel-Prozessor, entweder nativ oder in der Windows on Windows-Umgebung auf einer 64-Bit-Plattform (WOW64).
• Keine : Eine unbekannte oder nicht spezifizierte Kombination von Prozessor und Bits pro Wort.

Ich verwende in diesem Beispiel PowerShell, um die Methode aufzurufen.

Answer 2

Sie können die CorFlags CLI Werkzeug (zum Beispiel, C:\Program Dateien \Microsoft SDKs \Windows\v7.0\Bin\CorFlags.exe ), um den Status einer Baugruppe zu ermitteln, sollten Sie anhand der Ausgabe und des Öffnens einer Baugruppe als binäres Asset feststellen können, wo Sie suchen müssen, um festzustellen, ob das 32BIT-Flag auf 1 gesetzt ist ( x86 ) oder 0 ( Jede CPU o x64 abhängig von PE ):

Option    | PE    | 32BIT
----------|-------|---------
x86       | PE32  | 1
Any CPU   | PE32  | 0
x64       | PE32+ | 0

Der Blogbeitrag x64-Entwicklung mit .NET hat einige Informationen über corflags .

Noch besser: Sie können verwenden. Module.GetPEKind um festzustellen, ob eine Baugruppe PortableExecutableKinds Wert PE32Plus (64-bit), Required32Bit (32-Bit und WOW), oder ILOnly (jede CPU) zusammen mit anderen Attributen.

Answer 3

Nur zur Klarstellung: CorFlags.exe ist Teil des Programms .NET Framework SDK . Ich habe die Entwicklungstools auf meinem Rechner, und der einfachste Weg für mich zu bestimmen, ob eine DLL nur 32-Bit ist, ist zu:

1. Öffnen Sie die Visual Studio-Eingabeaufforderung (unter Windows: Menü Start/Programme/Microsoft Visual Studio/Visual Studio Tools/Visual Studio 2008 Command Prompt)

2. CD in das Verzeichnis, das die betreffende DLL enthält

3. Führen Sie corflags wie folgt aus: corflags MyAssembly.dll

Sie erhalten dann eine Ausgabe wie diese:

Microsoft (R) .NET Framework CorFlags Conversion Tool.  Version  3.5.21022.8
Copyright (c) Microsoft Corporation.  All rights reserved.

Version   : v2.0.50727
CLR Header: 2.5
PE        : PE32
CorFlags  : 3
ILONLY    : 1
32BIT     : 1
Signed    : 0

Gemäß den Kommentaren sind die obigen Flaggen wie folgt zu lesen:

• Beliebige CPU: PE = PE32 und 32BIT = 0
• x86: PE = PE32 und 32BIT = 1
• 64-Bit: PE = PE32+ und 32BIT = 0

Answer 4

Wie wäre es, wenn Sie einfach Ihren eigenen Text schreiben? Der Kern der PE-Architektur wurde seit seiner Implementierung in Windows 95 nicht mehr ernsthaft verändert. Hier ist ein C#-Beispiel:

    public static ushort GetPEArchitecture(string pFilePath)
    {
        ushort architecture = 0;
        try
        {
            using (System.IO.FileStream fStream = new System.IO.FileStream(pFilePath, System.IO.FileMode.Open, System.IO.FileAccess.Read))
            {
                using (System.IO.BinaryReader bReader = new System.IO.BinaryReader(fStream))
                {
                    if (bReader.ReadUInt16() == 23117) //check the MZ signature
                    {
                        fStream.Seek(0x3A, System.IO.SeekOrigin.Current); //seek to e_lfanew.
                        fStream.Seek(bReader.ReadUInt32(), System.IO.SeekOrigin.Begin); //seek to the start of the NT header.
                        if (bReader.ReadUInt32() == 17744) //check the PE\0\0 signature.
                        {
                            fStream.Seek(20, System.IO.SeekOrigin.Current); //seek past the file header,
                            architecture = bReader.ReadUInt16(); //read the magic number of the optional header.
                        }
                    }
                }
            }
        }
        catch (Exception) { /* TODO: Any exception handling you want to do, personally I just take 0 as a sign of failure */}
        //if architecture returns 0, there has been an error.
        return architecture;
    }
}

Die aktuellen Konstanten sind jetzt:

0x10B - PE32  format.
0x20B - PE32+ format.

Aber mit dieser Methode ist es möglich, neue Konstanten zu verwenden, indem man die Rückgabe nach eigenem Ermessen validiert.

Answer 5

DotPeek von JetBrains bietet eine schnelle und einfache Möglichkeit, msil(anycpu), x86, x64 zu sehen