Wie kann ich das Subsystem ermitteln, das von einer bestimmten .NET-Assembly verwendet wird?

Question

In einer C# -Anwendung möchte ich feststellen, ob eine andere .NET-Anwendung eine Konsolenanwendung ist oder nicht.

Kann dies mit den Reflektions-APIs geschehen?

EDIT: OK, es sieht nicht so aus, als würde ich eine gute Antwort auf diese Frage bekommen, weil es nicht so aussieht, als würde das Framework die Funktionalität offen legen, die ich möchte. Ich kramte in der PE/COFF spec und kam mit dieser:

/// <summary> 
/// Parses the PE header and determines whether the given assembly is a console application. 
/// </summary> 
/// <param name="assemblyPath">The path of the assembly to check.</param> 
/// <returns>True if the given assembly is a console application; false otherwise.</returns> 
/// <remarks>The magic numbers in this method are extracted from the PE/COFF file 
/// format specification available from http://www.microsoft.com/whdc/system/platform/firmware/pecoff.mspx 
/// </remarks> 
bool AssemblyUsesConsoleSubsystem(string assemblyPath) 
{ 
    using (var s = new FileStream(assemblyPath, FileMode.Open, FileAccess.Read)) 
    { 
     var rawPeSignatureOffset = new byte[4]; 
     s.Seek(0x3c, SeekOrigin.Begin); 
     s.Read(rawPeSignatureOffset, 0, 4); 
     int peSignatureOffset = rawPeSignatureOffset[0]; 
     peSignatureOffset |= rawPeSignatureOffset[1] << 8; 
     peSignatureOffset |= rawPeSignatureOffset[2] << 16; 
     peSignatureOffset |= rawPeSignatureOffset[3] << 24; 
     var coffHeader = new byte[24]; 
     s.Seek(peSignatureOffset, SeekOrigin.Begin); 
     s.Read(coffHeader, 0, 24); 
     byte[] signature = {(byte)'P', (byte)'E', (byte)'\0', (byte)'\0'}; 
     for (int index = 0; index < 4; index++) 
     { 
      Assert.That(coffHeader[index], Is.EqualTo(signature[index]), 
       "Attempted to check a non PE file for the console subsystem!"); 
     } 
     var subsystemBytes = new byte[2]; 
     s.Seek(68, SeekOrigin.Current); 
     s.Read(subsystemBytes, 0, 2); 
     int subSystem = subsystemBytes[0] | subsystemBytes[1] << 8; 
     return subSystem == 3; /*IMAGE_SUBSYSTEM_WINDOWS_CUI*/ 
    } 
} 

Answer 1

dies von verwalteten Code außerhalb des Gültigkeitsbereichs. Von .net Ansicht Konsole und Win-Anwendungen sind die gleichen, müssen Sie in PE-Datei-Header schauen. Suche nach Arbeit „Subsystem“ auf dieser Seite http://msdn.microsoft.com/en-us/magazine/bb985997.aspx

Answer 2

Ich glaube nicht, dass es eine wissenschaftliche Art und Weise ist es zu bestimmen, die am nächsten Abhilfe, die mir in den Sinn kommt Reflexion verwendet zu überprüfen, ob die Anwendungsreferenzen und lädt die WinForms-Assembly, aber ich bin mir nicht ganz sicher. Könnte es versuchen.

Answer 3

Ich nehme an, es sollte die gleiche wie für native Anwendungen so dann könnten Sie in der Lage sein, diesen Artikel von C++ zu C# zur Anpassung der PE-Header lesen: How To Determine Whether an Application is Console or GUI

Answer 4

Die SHGetFileInfo Funktion kann dies tun:

[DllImport("shell32.dll", CharSet=CharSet.Auto, EntryPoint="SHGetFileInfo")] 
public static extern ExeType GetExeType(string pszPath, uint dwFileAttributes = 0, IntPtr psfi = default(IntPtr), uint cbFileInfo = 0, uint uFlags = 0x2000); 

[Flags] 
public enum ExeType 
{ 
    None = 0, 
    WinNT = 0x04000000, 
    PE = ((int)'P') | ((int)'E' << 8), 
    NE = ((int)'N') | ((int)'E' << 8), 
    MZ = ((int)'M') | ((int)'Z' << 8), 
} 

Dann wird gemäß der Spezifikation, wenn es nur MZ oder PE ist, ist es in der Konsole geöffnet ist, andernfalls (Wenn eine Version angegeben wird, ist sie in einem Fenster geöffnet.

ExeType type = GetExeType("program.exe"); 
if(type == ExeType.PE || type == ExeType.MZ) return "console"; 
else return "window";