Wie erkennt man, ob die DLL ein Debug- oder Release-Build ist (in .NET)

Question

Mögliches Duplikat:
Wie kann man feststellen, ob eine .NET-Anwendung im DEBUG- oder RELEASE-Modus kompiliert wurde?

Ich bin sicher, dass diese Frage schon einmal gestellt wurde, aber Google und die SO-Suche haben mich enttäuscht.

Wie kann ich feststellen, ob eine DLL ein Release-Build oder ein Debug-Build ist?

Answer 1

IMHO ist die obige Anwendung wirklich irreführend; sie sucht nur nach dem IsJITTrackingEnabled, das völlig unabhängig davon ist, ob der Code für die Optimierung und die JIT-Optimierung kompiliert ist oder nicht.

Das DebuggableAttribute ist vorhanden, wenn Sie im Release-Modus kompilieren und DebugOutput auf etwas anderes als "none" setzen.

Sie müssen auch Folgendes definieren genau was mit "Debug" vs. "Release" gemeint ist...

Meinen Sie, dass die Anwendung mit Code-Optimierung konfiguriert ist? Meinen Sie, dass Sie den VS/JIT-Debugger damit verbinden können? Meinen Sie, dass sie DebugOutput generiert? Meinen Sie, dass sie die DEBUG-Konstante definiert? Denken Sie daran, dass Sie Methoden mit dem Attribut System.Diagnostics.Conditional() bedingt kompilieren können.

IMHO, wenn jemand fragt, ob eine Baugruppe "Debug" oder "Release" ist oder nicht, meint er eigentlich, ob der Code optimiert ist...

Möchten Sie dies manuell oder programmgesteuert tun?

Manuell : Sie müssen den Wert der Bitmaske DebuggableAttribute für die Metadaten der Assembly anzeigen. Hier ist, wie Sie es tun:

1. Öffnen Sie die Baugruppe in ILDASM
2. Öffnen Sie das Manifest
3. Schauen Sie sich die DebuggableAttribute-Bitmaske an. Wenn das DebuggableAttribute nicht vorhanden ist, handelt es sich definitiv um eine optimierte Assembly.
4. Wenn es vorhanden ist, sehen Sie sich das 4. Byte an - wenn es eine '0' ist, ist es JIT-optimiert - alles andere ist es nicht:

// Metadaten Version: v4.0.30319 .... // .custom instance void [mscorlib]System.Diagnostics.DebuggableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggableAttribute/DebuggingModes) = ( 01 00 02 00 00 00 00 00 )

Programmatisch Wenn man davon ausgeht, dass man programmatisch wissen will, ob der Code JITOptimiert ist, ist hier die korrekte Implementierung (in einer einfachen Konsolenanwendung):

void Main()
{
    var HasDebuggableAttribute = false;
    var IsJITOptimized = false;
    var IsJITTrackingEnabled = false;
    var BuildType = "";
    var DebugOutput = "";

    var ReflectedAssembly = Assembly.LoadFile(@"path to the dll you are testing");
    object[] attribs = ReflectedAssembly.GetCustomAttributes(typeof(DebuggableAttribute), false);

    // If the 'DebuggableAttribute' is not found then it is definitely an OPTIMIZED build
    if (attribs.Length > 0)
    {
        // Just because the 'DebuggableAttribute' is found doesn't necessarily mean
        // it's a DEBUG build; we have to check the JIT Optimization flag
        // i.e. it could have the "generate PDB" checked but have JIT Optimization enabled
        DebuggableAttribute debuggableAttribute = attribs[0] as DebuggableAttribute;
        if (debuggableAttribute != null)
        {
            HasDebuggableAttribute = true;
            IsJITOptimized = !debuggableAttribute.IsJITOptimizerDisabled;

            // IsJITTrackingEnabled - Gets a value that indicates whether the runtime will track information during code generation for the debugger.
            IsJITTrackingEnabled = debuggableAttribute.IsJITTrackingEnabled;
            BuildType = debuggableAttribute.IsJITOptimizerDisabled ? "Debug" : "Release";

            // check for Debug Output "full" or "pdb-only"
            DebugOutput = (debuggableAttribute.DebuggingFlags &
                            DebuggableAttribute.DebuggingModes.Default) !=
                            DebuggableAttribute.DebuggingModes.None
                            ? "Full" : "pdb-only";
        }
    }
    else
    {
        IsJITOptimized = true;
        BuildType = "Release";
    }

    Console.WriteLine($"{nameof(HasDebuggableAttribute)}: {HasDebuggableAttribute}");
    Console.WriteLine($"{nameof(IsJITOptimized)}: {IsJITOptimized}");
    Console.WriteLine($"{nameof(IsJITTrackingEnabled)}: {IsJITTrackingEnabled}");
    Console.WriteLine($"{nameof(BuildType)}: {BuildType}");
    Console.WriteLine($"{nameof(DebugOutput)}: {DebugOutput}");
}

Ich habe diese Umsetzung in meinem Blog bereitgestellt:

So erkennen Sie, ob eine Baugruppe Debug oder Release ist

Answer 2

Die einzige Möglichkeit, dies zu tun, besteht darin, die kompilierten Assemblies selbst zu überprüfen. Es gibt dieses sehr nützliche Tool namens ".NET Assembly Information", das Sie unter aquí von Rotem Bloom. Nach der Installation assoziiert es sich mit .dll-Dateien, um sie mit sich selbst zu öffnen. Nach der Installation können Sie einfach auf die zu öffnende Assembly doppelklicken und Sie erhalten die Assembly-Details, wie in den Screenshots unten dargestellt. Dort können Sie erkennen, ob sie debug kompiliert ist oder nicht.

Ich hoffe, das hilft